diff --git a/wemm/lib/python3.10/site-packages/botocore/data/ivs/2020-07-14/endpoint-rule-set-1.json.gz b/wemm/lib/python3.10/site-packages/botocore/data/ivs/2020-07-14/endpoint-rule-set-1.json.gz
new file mode 100644
index 0000000000000000000000000000000000000000..6e59797cb32dc88245b85702b7a679a1e37049eb
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/botocore/data/ivs/2020-07-14/endpoint-rule-set-1.json.gz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c33ca625b69f3d08bdca7ee800860952e37438e73c37458e1dd927c31ada3c65
+size 1286
diff --git a/wemm/lib/python3.10/site-packages/torchvision/__pycache__/__init__.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ed00b6278fd02b495cca32bf52e126aeacf8a625
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/__pycache__/__init__.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/__pycache__/extension.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/__pycache__/extension.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d346636c6c01f1fdf2e3b822fa895b97f8a43821
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/__pycache__/extension.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/datapoints/__pycache__/__init__.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/datapoints/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c7677eaa5c98f4235da827dc5e62eeff0b0da437
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/datapoints/__pycache__/__init__.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/datapoints/__pycache__/_video.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/datapoints/__pycache__/_video.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a26a9d86c8cc6e864dcde534b56bec6074314a4c
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/datapoints/__pycache__/_video.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/datapoints/_dataset_wrapper.py b/wemm/lib/python3.10/site-packages/torchvision/datapoints/_dataset_wrapper.py
new file mode 100644
index 0000000000000000000000000000000000000000..87ce3ba93a13ecfd0661fd5cfbfa588ee3582bb0
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/datapoints/_dataset_wrapper.py
@@ -0,0 +1,499 @@
+# type: ignore
+
+from __future__ import annotations
+
+import contextlib
+from collections import defaultdict
+
+import torch
+from torch.utils.data import Dataset
+
+from torchvision import datapoints, datasets
+from torchvision.transforms.v2 import functional as F
+
+__all__ = ["wrap_dataset_for_transforms_v2"]
+
+
+def wrap_dataset_for_transforms_v2(dataset):
+ """[BETA] Wrap a ``torchvision.dataset`` for usage with :mod:`torchvision.transforms.v2`.
+
+ .. v2betastatus:: wrap_dataset_for_transforms_v2 function
+
+ Example:
+ >>> dataset = torchvision.datasets.CocoDetection(...)
+ >>> dataset = wrap_dataset_for_transforms_v2(dataset)
+
+ .. note::
+
+ For now, only the most popular datasets are supported. Furthermore, the wrapper only supports dataset
+ configurations that are fully supported by ``torchvision.transforms.v2``. If you encounter an error prompting you
+ to raise an issue to ``torchvision`` for a dataset or configuration that you need, please do so.
+
+ The dataset samples are wrapped according to the description below.
+
+ Special cases:
+
+ * :class:`~torchvision.datasets.CocoDetection`: Instead of returning the target as list of dicts, the wrapper
+ returns a dict of lists. In addition, the key-value-pairs ``"boxes"`` (in ``XYXY`` coordinate format),
+ ``"masks"`` and ``"labels"`` are added and wrap the data in the corresponding ``torchvision.datapoints``.
+ The original keys are preserved.
+ * :class:`~torchvision.datasets.VOCDetection`: The key-value-pairs ``"boxes"`` and ``"labels"`` are added to
+ the target and wrap the data in the corresponding ``torchvision.datapoints``. The original keys are
+ preserved.
+ * :class:`~torchvision.datasets.CelebA`: The target for ``target_type="bbox"`` is converted to the ``XYXY``
+ coordinate format and wrapped into a :class:`~torchvision.datapoints.BoundingBox` datapoint.
+ * :class:`~torchvision.datasets.Kitti`: Instead returning the target as list of dictsthe wrapper returns a dict
+ of lists. In addition, the key-value-pairs ``"boxes"`` and ``"labels"`` are added and wrap the data
+ in the corresponding ``torchvision.datapoints``. The original keys are preserved.
+ * :class:`~torchvision.datasets.OxfordIIITPet`: The target for ``target_type="segmentation"`` is wrapped into a
+ :class:`~torchvision.datapoints.Mask` datapoint.
+ * :class:`~torchvision.datasets.Cityscapes`: The target for ``target_type="semantic"`` is wrapped into a
+ :class:`~torchvision.datapoints.Mask` datapoint. The target for ``target_type="instance"`` is *replaced* by
+ a dictionary with the key-value-pairs ``"masks"`` (as :class:`~torchvision.datapoints.Mask` datapoint) and
+ ``"labels"``.
+ * :class:`~torchvision.datasets.WIDERFace`: The value for key ``"bbox"`` in the target is converted to ``XYXY``
+ coordinate format and wrapped into a :class:`~torchvision.datapoints.BoundingBox` datapoint.
+
+ Image classification datasets
+
+ This wrapper is a no-op for image classification datasets, since they were already fully supported by
+ :mod:`torchvision.transforms` and thus no change is needed for :mod:`torchvision.transforms.v2`.
+
+ Segmentation datasets
+
+ Segmentation datasets, e.g. :class:`~torchvision.datasets.VOCSegmentation` return a two-tuple of
+ :class:`PIL.Image.Image`'s. This wrapper leaves the image as is (first item), while wrapping the
+ segmentation mask into a :class:`~torchvision.datapoints.Mask` (second item).
+
+ Video classification datasets
+
+ Video classification datasets, e.g. :class:`~torchvision.datasets.Kinetics` return a three-tuple containing a
+ :class:`torch.Tensor` for the video and audio and a :class:`int` as label. This wrapper wraps the video into a
+ :class:`~torchvision.datapoints.Video` while leaving the other items as is.
+
+ .. note::
+
+ Only datasets constructed with ``output_format="TCHW"`` are supported, since the alternative
+ ``output_format="THWC"`` is not supported by :mod:`torchvision.transforms.v2`.
+
+ Args:
+ dataset: the dataset instance to wrap for compatibility with transforms v2.
+ """
+ return VisionDatasetDatapointWrapper(dataset)
+
+
+class WrapperFactories(dict):
+ def register(self, dataset_cls):
+ def decorator(wrapper_factory):
+ self[dataset_cls] = wrapper_factory
+ return wrapper_factory
+
+ return decorator
+
+
+# We need this two-stage design, i.e. a wrapper factory producing the actual wrapper, since some wrappers depend on the
+# dataset instance rather than just the class, since they require the user defined instance attributes. Thus, we can
+# provide a wrapping from the dataset class to the factory here, but can only instantiate the wrapper at runtime when
+# we have access to the dataset instance.
+WRAPPER_FACTORIES = WrapperFactories()
+
+
+class VisionDatasetDatapointWrapper(Dataset):
+ def __init__(self, dataset):
+ dataset_cls = type(dataset)
+
+ if not isinstance(dataset, datasets.VisionDataset):
+ raise TypeError(
+ f"This wrapper is meant for subclasses of `torchvision.datasets.VisionDataset`, "
+ f"but got a '{dataset_cls.__name__}' instead."
+ )
+
+ for cls in dataset_cls.mro():
+ if cls in WRAPPER_FACTORIES:
+ wrapper_factory = WRAPPER_FACTORIES[cls]
+ break
+ elif cls is datasets.VisionDataset:
+ # TODO: If we have documentation on how to do that, put a link in the error message.
+ msg = f"No wrapper exists for dataset class {dataset_cls.__name__}. Please wrap the output yourself."
+ if dataset_cls in datasets.__dict__.values():
+ msg = (
+ f"{msg} If an automated wrapper for this dataset would be useful for you, "
+ f"please open an issue at https://github.com/pytorch/vision/issues."
+ )
+ raise TypeError(msg)
+
+ self._dataset = dataset
+ self._wrapper = wrapper_factory(dataset)
+
+ # We need to disable the transforms on the dataset here to be able to inject the wrapping before we apply them.
+ # Although internally, `datasets.VisionDataset` merges `transform` and `target_transform` into the joint
+ # `transforms`
+ # https://github.com/pytorch/vision/blob/135a0f9ea9841b6324b4fe8974e2543cbb95709a/torchvision/datasets/vision.py#L52-L54
+ # some (if not most) datasets still use `transform` and `target_transform` individually. Thus, we need to
+ # disable all three here to be able to extract the untransformed sample to wrap.
+ self.transform, dataset.transform = dataset.transform, None
+ self.target_transform, dataset.target_transform = dataset.target_transform, None
+ self.transforms, dataset.transforms = dataset.transforms, None
+
+ def __getattr__(self, item):
+ with contextlib.suppress(AttributeError):
+ return object.__getattribute__(self, item)
+
+ return getattr(self._dataset, item)
+
+ def __getitem__(self, idx):
+ # This gets us the raw sample since we disabled the transforms for the underlying dataset in the constructor
+ # of this class
+ sample = self._dataset[idx]
+
+ sample = self._wrapper(idx, sample)
+
+ # Regardless of whether the user has supplied the transforms individually (`transform` and `target_transform`)
+ # or joint (`transforms`), we can access the full functionality through `transforms`
+ if self.transforms is not None:
+ sample = self.transforms(*sample)
+
+ return sample
+
+ def __len__(self):
+ return len(self._dataset)
+
+
+def raise_not_supported(description):
+ raise RuntimeError(
+ f"{description} is currently not supported by this wrapper. "
+ f"If this would be helpful for you, please open an issue at https://github.com/pytorch/vision/issues."
+ )
+
+
+def identity(item):
+ return item
+
+
+def identity_wrapper_factory(dataset):
+ def wrapper(idx, sample):
+ return sample
+
+ return wrapper
+
+
+def pil_image_to_mask(pil_image):
+ return datapoints.Mask(pil_image)
+
+
+def list_of_dicts_to_dict_of_lists(list_of_dicts):
+ dict_of_lists = defaultdict(list)
+ for dct in list_of_dicts:
+ for key, value in dct.items():
+ dict_of_lists[key].append(value)
+ return dict(dict_of_lists)
+
+
+def wrap_target_by_type(target, *, target_types, type_wrappers):
+ if not isinstance(target, (tuple, list)):
+ target = [target]
+
+ wrapped_target = tuple(
+ type_wrappers.get(target_type, identity)(item) for target_type, item in zip(target_types, target)
+ )
+
+ if len(wrapped_target) == 1:
+ wrapped_target = wrapped_target[0]
+
+ return wrapped_target
+
+
+def classification_wrapper_factory(dataset):
+ return identity_wrapper_factory(dataset)
+
+
+for dataset_cls in [
+ datasets.Caltech256,
+ datasets.CIFAR10,
+ datasets.CIFAR100,
+ datasets.ImageNet,
+ datasets.MNIST,
+ datasets.FashionMNIST,
+ datasets.GTSRB,
+ datasets.DatasetFolder,
+ datasets.ImageFolder,
+]:
+ WRAPPER_FACTORIES.register(dataset_cls)(classification_wrapper_factory)
+
+
+def segmentation_wrapper_factory(dataset):
+ def wrapper(idx, sample):
+ image, mask = sample
+ return image, pil_image_to_mask(mask)
+
+ return wrapper
+
+
+for dataset_cls in [
+ datasets.VOCSegmentation,
+]:
+ WRAPPER_FACTORIES.register(dataset_cls)(segmentation_wrapper_factory)
+
+
+def video_classification_wrapper_factory(dataset):
+ if dataset.video_clips.output_format == "THWC":
+ raise RuntimeError(
+ f"{type(dataset).__name__} with `output_format='THWC'` is not supported by this wrapper, "
+ f"since it is not compatible with the transformations. Please use `output_format='TCHW'` instead."
+ )
+
+ def wrapper(idx, sample):
+ video, audio, label = sample
+
+ video = datapoints.Video(video)
+
+ return video, audio, label
+
+ return wrapper
+
+
+for dataset_cls in [
+ datasets.HMDB51,
+ datasets.Kinetics,
+ datasets.UCF101,
+]:
+ WRAPPER_FACTORIES.register(dataset_cls)(video_classification_wrapper_factory)
+
+
+@WRAPPER_FACTORIES.register(datasets.Caltech101)
+def caltech101_wrapper_factory(dataset):
+ if "annotation" in dataset.target_type:
+ raise_not_supported("Caltech101 dataset with `target_type=['annotation', ...]`")
+
+ return classification_wrapper_factory(dataset)
+
+
+@WRAPPER_FACTORIES.register(datasets.CocoDetection)
+def coco_dectection_wrapper_factory(dataset):
+ def segmentation_to_mask(segmentation, *, spatial_size):
+ from pycocotools import mask
+
+ segmentation = (
+ mask.frPyObjects(segmentation, *spatial_size)
+ if isinstance(segmentation, dict)
+ else mask.merge(mask.frPyObjects(segmentation, *spatial_size))
+ )
+ return torch.from_numpy(mask.decode(segmentation))
+
+ def wrapper(idx, sample):
+ image_id = dataset.ids[idx]
+
+ image, target = sample
+
+ if not target:
+ return image, dict(image_id=image_id)
+
+ batched_target = list_of_dicts_to_dict_of_lists(target)
+
+ batched_target["image_id"] = image_id
+
+ spatial_size = tuple(F.get_spatial_size(image))
+ batched_target["boxes"] = F.convert_format_bounding_box(
+ datapoints.BoundingBox(
+ batched_target["bbox"],
+ format=datapoints.BoundingBoxFormat.XYWH,
+ spatial_size=spatial_size,
+ ),
+ new_format=datapoints.BoundingBoxFormat.XYXY,
+ )
+ batched_target["masks"] = datapoints.Mask(
+ torch.stack(
+ [
+ segmentation_to_mask(segmentation, spatial_size=spatial_size)
+ for segmentation in batched_target["segmentation"]
+ ]
+ ),
+ )
+ batched_target["labels"] = torch.tensor(batched_target["category_id"])
+
+ return image, batched_target
+
+ return wrapper
+
+
+WRAPPER_FACTORIES.register(datasets.CocoCaptions)(identity_wrapper_factory)
+
+
+VOC_DETECTION_CATEGORIES = [
+ "__background__",
+ "aeroplane",
+ "bicycle",
+ "bird",
+ "boat",
+ "bottle",
+ "bus",
+ "car",
+ "cat",
+ "chair",
+ "cow",
+ "diningtable",
+ "dog",
+ "horse",
+ "motorbike",
+ "person",
+ "pottedplant",
+ "sheep",
+ "sofa",
+ "train",
+ "tvmonitor",
+]
+VOC_DETECTION_CATEGORY_TO_IDX = dict(zip(VOC_DETECTION_CATEGORIES, range(len(VOC_DETECTION_CATEGORIES))))
+
+
+@WRAPPER_FACTORIES.register(datasets.VOCDetection)
+def voc_detection_wrapper_factory(dataset):
+ def wrapper(idx, sample):
+ image, target = sample
+
+ batched_instances = list_of_dicts_to_dict_of_lists(target["annotation"]["object"])
+
+ target["boxes"] = datapoints.BoundingBox(
+ [
+ [int(bndbox[part]) for part in ("xmin", "ymin", "xmax", "ymax")]
+ for bndbox in batched_instances["bndbox"]
+ ],
+ format=datapoints.BoundingBoxFormat.XYXY,
+ spatial_size=(image.height, image.width),
+ )
+ target["labels"] = torch.tensor(
+ [VOC_DETECTION_CATEGORY_TO_IDX[category] for category in batched_instances["name"]]
+ )
+
+ return image, target
+
+ return wrapper
+
+
+@WRAPPER_FACTORIES.register(datasets.SBDataset)
+def sbd_wrapper(dataset):
+ if dataset.mode == "boundaries":
+ raise_not_supported("SBDataset with mode='boundaries'")
+
+ return segmentation_wrapper_factory(dataset)
+
+
+@WRAPPER_FACTORIES.register(datasets.CelebA)
+def celeba_wrapper_factory(dataset):
+ if any(target_type in dataset.target_type for target_type in ["attr", "landmarks"]):
+ raise_not_supported("`CelebA` dataset with `target_type=['attr', 'landmarks', ...]`")
+
+ def wrapper(idx, sample):
+ image, target = sample
+
+ target = wrap_target_by_type(
+ target,
+ target_types=dataset.target_type,
+ type_wrappers={
+ "bbox": lambda item: F.convert_format_bounding_box(
+ datapoints.BoundingBox(
+ item,
+ format=datapoints.BoundingBoxFormat.XYWH,
+ spatial_size=(image.height, image.width),
+ ),
+ new_format=datapoints.BoundingBoxFormat.XYXY,
+ ),
+ },
+ )
+
+ return image, target
+
+ return wrapper
+
+
+KITTI_CATEGORIES = ["Car", "Van", "Truck", "Pedestrian", "Person_sitting", "Cyclist", "Tram", "Misc", "DontCare"]
+KITTI_CATEGORY_TO_IDX = dict(zip(KITTI_CATEGORIES, range(len(KITTI_CATEGORIES))))
+
+
+@WRAPPER_FACTORIES.register(datasets.Kitti)
+def kitti_wrapper_factory(dataset):
+ def wrapper(idx, sample):
+ image, target = sample
+
+ if target is not None:
+ target = list_of_dicts_to_dict_of_lists(target)
+
+ target["boxes"] = datapoints.BoundingBox(
+ target["bbox"], format=datapoints.BoundingBoxFormat.XYXY, spatial_size=(image.height, image.width)
+ )
+ target["labels"] = torch.tensor([KITTI_CATEGORY_TO_IDX[category] for category in target["type"]])
+
+ return image, target
+
+ return wrapper
+
+
+@WRAPPER_FACTORIES.register(datasets.OxfordIIITPet)
+def oxford_iiit_pet_wrapper_factor(dataset):
+ def wrapper(idx, sample):
+ image, target = sample
+
+ if target is not None:
+ target = wrap_target_by_type(
+ target,
+ target_types=dataset._target_types,
+ type_wrappers={
+ "segmentation": pil_image_to_mask,
+ },
+ )
+
+ return image, target
+
+ return wrapper
+
+
+@WRAPPER_FACTORIES.register(datasets.Cityscapes)
+def cityscapes_wrapper_factory(dataset):
+ if any(target_type in dataset.target_type for target_type in ["polygon", "color"]):
+ raise_not_supported("`Cityscapes` dataset with `target_type=['polygon', 'color', ...]`")
+
+ def instance_segmentation_wrapper(mask):
+ # See https://github.com/mcordts/cityscapesScripts/blob/8da5dd00c9069058ccc134654116aac52d4f6fa2/cityscapesscripts/preparation/json2instanceImg.py#L7-L21
+ data = pil_image_to_mask(mask)
+ masks = []
+ labels = []
+ for id in data.unique():
+ masks.append(data == id)
+ label = id
+ if label >= 1_000:
+ label //= 1_000
+ labels.append(label)
+ return dict(masks=datapoints.Mask(torch.stack(masks)), labels=torch.stack(labels))
+
+ def wrapper(idx, sample):
+ image, target = sample
+
+ target = wrap_target_by_type(
+ target,
+ target_types=dataset.target_type,
+ type_wrappers={
+ "instance": instance_segmentation_wrapper,
+ "semantic": pil_image_to_mask,
+ },
+ )
+
+ return image, target
+
+ return wrapper
+
+
+@WRAPPER_FACTORIES.register(datasets.WIDERFace)
+def widerface_wrapper(dataset):
+ def wrapper(idx, sample):
+ image, target = sample
+
+ if target is not None:
+ target["bbox"] = F.convert_format_bounding_box(
+ datapoints.BoundingBox(
+ target["bbox"], format=datapoints.BoundingBoxFormat.XYWH, spatial_size=(image.height, image.width)
+ ),
+ new_format=datapoints.BoundingBoxFormat.XYXY,
+ )
+
+ return image, target
+
+ return wrapper
diff --git a/wemm/lib/python3.10/site-packages/torchvision/datasets/clevr.py b/wemm/lib/python3.10/site-packages/torchvision/datasets/clevr.py
new file mode 100644
index 0000000000000000000000000000000000000000..94e261e335524a911e4dbc82bd5a1882114bf0a6
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/datasets/clevr.py
@@ -0,0 +1,88 @@
+import json
+import pathlib
+from typing import Any, Callable, List, Optional, Tuple
+from urllib.parse import urlparse
+
+from PIL import Image
+
+from .utils import download_and_extract_archive, verify_str_arg
+from .vision import VisionDataset
+
+
+class CLEVRClassification(VisionDataset):
+ """`CLEVR `_ classification dataset.
+
+ The number of objects in a scene are used as label.
+
+ Args:
+ root (string): Root directory of dataset where directory ``root/clevr`` exists or will be saved to if download is
+ set to True.
+ split (string, optional): The dataset split, supports ``"train"`` (default), ``"val"``, or ``"test"``.
+ transform (callable, optional): A function/transform that takes in an PIL image and returns a transformed
+ version. E.g, ``transforms.RandomCrop``
+ target_transform (callable, optional): A function/transform that takes in them target and transforms it.
+ download (bool, optional): If true, downloads the dataset from the internet and puts it in root directory. If
+ dataset is already downloaded, it is not downloaded again.
+ """
+
+ _URL = "https://dl.fbaipublicfiles.com/clevr/CLEVR_v1.0.zip"
+ _MD5 = "b11922020e72d0cd9154779b2d3d07d2"
+
+ def __init__(
+ self,
+ root: str,
+ split: str = "train",
+ transform: Optional[Callable] = None,
+ target_transform: Optional[Callable] = None,
+ download: bool = False,
+ ) -> None:
+ self._split = verify_str_arg(split, "split", ("train", "val", "test"))
+ super().__init__(root, transform=transform, target_transform=target_transform)
+ self._base_folder = pathlib.Path(self.root) / "clevr"
+ self._data_folder = self._base_folder / pathlib.Path(urlparse(self._URL).path).stem
+
+ if download:
+ self._download()
+
+ if not self._check_exists():
+ raise RuntimeError("Dataset not found or corrupted. You can use download=True to download it")
+
+ self._image_files = sorted(self._data_folder.joinpath("images", self._split).glob("*"))
+
+ self._labels: List[Optional[int]]
+ if self._split != "test":
+ with open(self._data_folder / "scenes" / f"CLEVR_{self._split}_scenes.json") as file:
+ content = json.load(file)
+ num_objects = {scene["image_filename"]: len(scene["objects"]) for scene in content["scenes"]}
+ self._labels = [num_objects[image_file.name] for image_file in self._image_files]
+ else:
+ self._labels = [None] * len(self._image_files)
+
+ def __len__(self) -> int:
+ return len(self._image_files)
+
+ def __getitem__(self, idx: int) -> Tuple[Any, Any]:
+ image_file = self._image_files[idx]
+ label = self._labels[idx]
+
+ image = Image.open(image_file).convert("RGB")
+
+ if self.transform:
+ image = self.transform(image)
+
+ if self.target_transform:
+ label = self.target_transform(label)
+
+ return image, label
+
+ def _check_exists(self) -> bool:
+ return self._data_folder.exists() and self._data_folder.is_dir()
+
+ def _download(self) -> None:
+ if self._check_exists():
+ return
+
+ download_and_extract_archive(self._URL, str(self._base_folder), md5=self._MD5)
+
+ def extra_repr(self) -> str:
+ return f"split={self._split}"
diff --git a/wemm/lib/python3.10/site-packages/torchvision/io/__pycache__/__init__.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/io/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f8b1c8ee7b0d85713c00a814adc1674dfc0c2343
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/io/__pycache__/__init__.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/io/__pycache__/_load_gpu_decoder.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/io/__pycache__/_load_gpu_decoder.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..9748c6ab5831278aafc56ecb519c54c6f0bc209f
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/io/__pycache__/_load_gpu_decoder.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/io/_load_gpu_decoder.py b/wemm/lib/python3.10/site-packages/torchvision/io/_load_gpu_decoder.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7869f0a9d1924b77255ac258e9fd9cc36127aae
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/io/_load_gpu_decoder.py
@@ -0,0 +1,8 @@
+from ..extension import _load_library
+
+
+try:
+ _load_library("Decoder")
+ _HAS_GPU_VIDEO_DECODER = True
+except (ImportError, OSError):
+ _HAS_GPU_VIDEO_DECODER = False
diff --git a/wemm/lib/python3.10/site-packages/torchvision/io/image.py b/wemm/lib/python3.10/site-packages/torchvision/io/image.py
new file mode 100644
index 0000000000000000000000000000000000000000..900ac4e36d2e435c3fa21822301200b9c778613d
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/io/image.py
@@ -0,0 +1,264 @@
+from enum import Enum
+from warnings import warn
+
+import torch
+
+from ..extension import _load_library
+from ..utils import _log_api_usage_once
+
+
+try:
+ _load_library("image")
+except (ImportError, OSError) as e:
+ warn(
+ f"Failed to load image Python extension: '{e}'"
+ f"If you don't plan on using image functionality from `torchvision.io`, you can ignore this warning. "
+ f"Otherwise, there might be something wrong with your environment. "
+ f"Did you have `libjpeg` or `libpng` installed before building `torchvision` from source?"
+ )
+
+
+class ImageReadMode(Enum):
+ """
+ Support for various modes while reading images.
+
+ Use ``ImageReadMode.UNCHANGED`` for loading the image as-is,
+ ``ImageReadMode.GRAY`` for converting to grayscale,
+ ``ImageReadMode.GRAY_ALPHA`` for grayscale with transparency,
+ ``ImageReadMode.RGB`` for RGB and ``ImageReadMode.RGB_ALPHA`` for
+ RGB with transparency.
+ """
+
+ UNCHANGED = 0
+ GRAY = 1
+ GRAY_ALPHA = 2
+ RGB = 3
+ RGB_ALPHA = 4
+
+
+def read_file(path: str) -> torch.Tensor:
+ """
+ Reads and outputs the bytes contents of a file as a uint8 Tensor
+ with one dimension.
+
+ Args:
+ path (str): the path to the file to be read
+
+ Returns:
+ data (Tensor)
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(read_file)
+ data = torch.ops.image.read_file(path)
+ return data
+
+
+def write_file(filename: str, data: torch.Tensor) -> None:
+ """
+ Writes the contents of an uint8 tensor with one dimension to a
+ file.
+
+ Args:
+ filename (str): the path to the file to be written
+ data (Tensor): the contents to be written to the output file
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(write_file)
+ torch.ops.image.write_file(filename, data)
+
+
+def decode_png(input: torch.Tensor, mode: ImageReadMode = ImageReadMode.UNCHANGED) -> torch.Tensor:
+ """
+ Decodes a PNG image into a 3 dimensional RGB or grayscale Tensor.
+ Optionally converts the image to the desired format.
+ The values of the output tensor are uint8 in [0, 255].
+
+ Args:
+ input (Tensor[1]): a one dimensional uint8 tensor containing
+ the raw bytes of the PNG image.
+ mode (ImageReadMode): the read mode used for optionally
+ converting the image. Default: ``ImageReadMode.UNCHANGED``.
+ See `ImageReadMode` class for more information on various
+ available modes.
+
+ Returns:
+ output (Tensor[image_channels, image_height, image_width])
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(decode_png)
+ output = torch.ops.image.decode_png(input, mode.value, False)
+ return output
+
+
+def encode_png(input: torch.Tensor, compression_level: int = 6) -> torch.Tensor:
+ """
+ Takes an input tensor in CHW layout and returns a buffer with the contents
+ of its corresponding PNG file.
+
+ Args:
+ input (Tensor[channels, image_height, image_width]): int8 image tensor of
+ ``c`` channels, where ``c`` must 3 or 1.
+ compression_level (int): Compression factor for the resulting file, it must be a number
+ between 0 and 9. Default: 6
+
+ Returns:
+ Tensor[1]: A one dimensional int8 tensor that contains the raw bytes of the
+ PNG file.
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(encode_png)
+ output = torch.ops.image.encode_png(input, compression_level)
+ return output
+
+
+def write_png(input: torch.Tensor, filename: str, compression_level: int = 6):
+ """
+ Takes an input tensor in CHW layout (or HW in the case of grayscale images)
+ and saves it in a PNG file.
+
+ Args:
+ input (Tensor[channels, image_height, image_width]): int8 image tensor of
+ ``c`` channels, where ``c`` must be 1 or 3.
+ filename (str): Path to save the image.
+ compression_level (int): Compression factor for the resulting file, it must be a number
+ between 0 and 9. Default: 6
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(write_png)
+ output = encode_png(input, compression_level)
+ write_file(filename, output)
+
+
+def decode_jpeg(
+ input: torch.Tensor, mode: ImageReadMode = ImageReadMode.UNCHANGED, device: str = "cpu"
+) -> torch.Tensor:
+ """
+ Decodes a JPEG image into a 3 dimensional RGB or grayscale Tensor.
+ Optionally converts the image to the desired format.
+ The values of the output tensor are uint8 between 0 and 255.
+
+ Args:
+ input (Tensor[1]): a one dimensional uint8 tensor containing
+ the raw bytes of the JPEG image. This tensor must be on CPU,
+ regardless of the ``device`` parameter.
+ mode (ImageReadMode): the read mode used for optionally
+ converting the image. The supported modes are: ``ImageReadMode.UNCHANGED``,
+ ``ImageReadMode.GRAY`` and ``ImageReadMode.RGB``
+ Default: ``ImageReadMode.UNCHANGED``.
+ See ``ImageReadMode`` class for more information on various
+ available modes.
+ device (str or torch.device): The device on which the decoded image will
+ be stored. If a cuda device is specified, the image will be decoded
+ with `nvjpeg `_. This is only
+ supported for CUDA version >= 10.1
+
+ .. betastatus:: device parameter
+
+ .. warning::
+ There is a memory leak in the nvjpeg library for CUDA versions < 11.6.
+ Make sure to rely on CUDA 11.6 or above before using ``device="cuda"``.
+
+ Returns:
+ output (Tensor[image_channels, image_height, image_width])
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(decode_jpeg)
+ device = torch.device(device)
+ if device.type == "cuda":
+ output = torch.ops.image.decode_jpeg_cuda(input, mode.value, device)
+ else:
+ output = torch.ops.image.decode_jpeg(input, mode.value)
+ return output
+
+
+def encode_jpeg(input: torch.Tensor, quality: int = 75) -> torch.Tensor:
+ """
+ Takes an input tensor in CHW layout and returns a buffer with the contents
+ of its corresponding JPEG file.
+
+ Args:
+ input (Tensor[channels, image_height, image_width])): int8 image tensor of
+ ``c`` channels, where ``c`` must be 1 or 3.
+ quality (int): Quality of the resulting JPEG file, it must be a number between
+ 1 and 100. Default: 75
+
+ Returns:
+ output (Tensor[1]): A one dimensional int8 tensor that contains the raw bytes of the
+ JPEG file.
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(encode_jpeg)
+ if quality < 1 or quality > 100:
+ raise ValueError("Image quality should be a positive number between 1 and 100")
+
+ output = torch.ops.image.encode_jpeg(input, quality)
+ return output
+
+
+def write_jpeg(input: torch.Tensor, filename: str, quality: int = 75):
+ """
+ Takes an input tensor in CHW layout and saves it in a JPEG file.
+
+ Args:
+ input (Tensor[channels, image_height, image_width]): int8 image tensor of ``c``
+ channels, where ``c`` must be 1 or 3.
+ filename (str): Path to save the image.
+ quality (int): Quality of the resulting JPEG file, it must be a number
+ between 1 and 100. Default: 75
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(write_jpeg)
+ output = encode_jpeg(input, quality)
+ write_file(filename, output)
+
+
+def decode_image(input: torch.Tensor, mode: ImageReadMode = ImageReadMode.UNCHANGED) -> torch.Tensor:
+ """
+ Detects whether an image is a JPEG or PNG and performs the appropriate
+ operation to decode the image into a 3 dimensional RGB or grayscale Tensor.
+
+ Optionally converts the image to the desired format.
+ The values of the output tensor are uint8 in [0, 255].
+
+ Args:
+ input (Tensor): a one dimensional uint8 tensor containing the raw bytes of the
+ PNG or JPEG image.
+ mode (ImageReadMode): the read mode used for optionally converting the image.
+ Default: ``ImageReadMode.UNCHANGED``.
+ See ``ImageReadMode`` class for more information on various
+ available modes.
+
+ Returns:
+ output (Tensor[image_channels, image_height, image_width])
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(decode_image)
+ output = torch.ops.image.decode_image(input, mode.value)
+ return output
+
+
+def read_image(path: str, mode: ImageReadMode = ImageReadMode.UNCHANGED) -> torch.Tensor:
+ """
+ Reads a JPEG or PNG image into a 3 dimensional RGB or grayscale Tensor.
+ Optionally converts the image to the desired format.
+ The values of the output tensor are uint8 in [0, 255].
+
+ Args:
+ path (str): path of the JPEG or PNG image.
+ mode (ImageReadMode): the read mode used for optionally converting the image.
+ Default: ``ImageReadMode.UNCHANGED``.
+ See ``ImageReadMode`` class for more information on various
+ available modes.
+
+ Returns:
+ output (Tensor[image_channels, image_height, image_width])
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(read_image)
+ data = read_file(path)
+ return decode_image(data, mode)
+
+
+def _read_png_16(path: str, mode: ImageReadMode = ImageReadMode.UNCHANGED) -> torch.Tensor:
+ data = read_file(path)
+ return torch.ops.image.decode_png(data, mode.value, True)
diff --git a/wemm/lib/python3.10/site-packages/torchvision/io/video.py b/wemm/lib/python3.10/site-packages/torchvision/io/video.py
new file mode 100644
index 0000000000000000000000000000000000000000..73e61dac18e3141d927e4ada00b0eb1251760f59
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/io/video.py
@@ -0,0 +1,415 @@
+import gc
+import math
+import os
+import re
+import warnings
+from fractions import Fraction
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import torch
+
+from ..utils import _log_api_usage_once
+from . import _video_opt
+
+try:
+ import av
+
+ av.logging.set_level(av.logging.ERROR)
+ if not hasattr(av.video.frame.VideoFrame, "pict_type"):
+ av = ImportError(
+ """\
+Your version of PyAV is too old for the necessary video operations in torchvision.
+If you are on Python 3.5, you will have to build from source (the conda-forge
+packages are not up-to-date). See
+https://github.com/mikeboers/PyAV#installation for instructions on how to
+install PyAV on your system.
+"""
+ )
+except ImportError:
+ av = ImportError(
+ """\
+PyAV is not installed, and is necessary for the video operations in torchvision.
+See https://github.com/mikeboers/PyAV#installation for instructions on how to
+install PyAV on your system.
+"""
+ )
+
+
+def _check_av_available() -> None:
+ if isinstance(av, Exception):
+ raise av
+
+
+def _av_available() -> bool:
+ return not isinstance(av, Exception)
+
+
+# PyAV has some reference cycles
+_CALLED_TIMES = 0
+_GC_COLLECTION_INTERVAL = 10
+
+
+def write_video(
+ filename: str,
+ video_array: torch.Tensor,
+ fps: float,
+ video_codec: str = "libx264",
+ options: Optional[Dict[str, Any]] = None,
+ audio_array: Optional[torch.Tensor] = None,
+ audio_fps: Optional[float] = None,
+ audio_codec: Optional[str] = None,
+ audio_options: Optional[Dict[str, Any]] = None,
+) -> None:
+ """
+ Writes a 4d tensor in [T, H, W, C] format in a video file
+
+ Args:
+ filename (str): path where the video will be saved
+ video_array (Tensor[T, H, W, C]): tensor containing the individual frames,
+ as a uint8 tensor in [T, H, W, C] format
+ fps (Number): video frames per second
+ video_codec (str): the name of the video codec, i.e. "libx264", "h264", etc.
+ options (Dict): dictionary containing options to be passed into the PyAV video stream
+ audio_array (Tensor[C, N]): tensor containing the audio, where C is the number of channels
+ and N is the number of samples
+ audio_fps (Number): audio sample rate, typically 44100 or 48000
+ audio_codec (str): the name of the audio codec, i.e. "mp3", "aac", etc.
+ audio_options (Dict): dictionary containing options to be passed into the PyAV audio stream
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(write_video)
+ _check_av_available()
+ video_array = torch.as_tensor(video_array, dtype=torch.uint8).numpy()
+
+ # PyAV does not support floating point numbers with decimal point
+ # and will throw OverflowException in case this is not the case
+ if isinstance(fps, float):
+ fps = np.round(fps)
+
+ with av.open(filename, mode="w") as container:
+ stream = container.add_stream(video_codec, rate=fps)
+ stream.width = video_array.shape[2]
+ stream.height = video_array.shape[1]
+ stream.pix_fmt = "yuv420p" if video_codec != "libx264rgb" else "rgb24"
+ stream.options = options or {}
+
+ if audio_array is not None:
+ audio_format_dtypes = {
+ "dbl": " 1 else "mono"
+ audio_sample_fmt = container.streams.audio[0].format.name
+
+ format_dtype = np.dtype(audio_format_dtypes[audio_sample_fmt])
+ audio_array = torch.as_tensor(audio_array).numpy().astype(format_dtype)
+
+ frame = av.AudioFrame.from_ndarray(audio_array, format=audio_sample_fmt, layout=audio_layout)
+
+ frame.sample_rate = audio_fps
+
+ for packet in a_stream.encode(frame):
+ container.mux(packet)
+
+ for packet in a_stream.encode():
+ container.mux(packet)
+
+ for img in video_array:
+ frame = av.VideoFrame.from_ndarray(img, format="rgb24")
+ frame.pict_type = "NONE"
+ for packet in stream.encode(frame):
+ container.mux(packet)
+
+ # Flush stream
+ for packet in stream.encode():
+ container.mux(packet)
+
+
+def _read_from_stream(
+ container: "av.container.Container",
+ start_offset: float,
+ end_offset: float,
+ pts_unit: str,
+ stream: "av.stream.Stream",
+ stream_name: Dict[str, Optional[Union[int, Tuple[int, ...], List[int]]]],
+) -> List["av.frame.Frame"]:
+ global _CALLED_TIMES, _GC_COLLECTION_INTERVAL
+ _CALLED_TIMES += 1
+ if _CALLED_TIMES % _GC_COLLECTION_INTERVAL == _GC_COLLECTION_INTERVAL - 1:
+ gc.collect()
+
+ if pts_unit == "sec":
+ # TODO: we should change all of this from ground up to simply take
+ # sec and convert to MS in C++
+ start_offset = int(math.floor(start_offset * (1 / stream.time_base)))
+ if end_offset != float("inf"):
+ end_offset = int(math.ceil(end_offset * (1 / stream.time_base)))
+ else:
+ warnings.warn("The pts_unit 'pts' gives wrong results. Please use pts_unit 'sec'.")
+
+ frames = {}
+ should_buffer = True
+ max_buffer_size = 5
+ if stream.type == "video":
+ # DivX-style packed B-frames can have out-of-order pts (2 frames in a single pkt)
+ # so need to buffer some extra frames to sort everything
+ # properly
+ extradata = stream.codec_context.extradata
+ # overly complicated way of finding if `divx_packed` is set, following
+ # https://github.com/FFmpeg/FFmpeg/commit/d5a21172283572af587b3d939eba0091484d3263
+ if extradata and b"DivX" in extradata:
+ # can't use regex directly because of some weird characters sometimes...
+ pos = extradata.find(b"DivX")
+ d = extradata[pos:]
+ o = re.search(rb"DivX(\d+)Build(\d+)(\w)", d)
+ if o is None:
+ o = re.search(rb"DivX(\d+)b(\d+)(\w)", d)
+ if o is not None:
+ should_buffer = o.group(3) == b"p"
+ seek_offset = start_offset
+ # some files don't seek to the right location, so better be safe here
+ seek_offset = max(seek_offset - 1, 0)
+ if should_buffer:
+ # FIXME this is kind of a hack, but we will jump to the previous keyframe
+ # so this will be safe
+ seek_offset = max(seek_offset - max_buffer_size, 0)
+ try:
+ # TODO check if stream needs to always be the video stream here or not
+ container.seek(seek_offset, any_frame=False, backward=True, stream=stream)
+ except av.AVError:
+ # TODO add some warnings in this case
+ # print("Corrupted file?", container.name)
+ return []
+ buffer_count = 0
+ try:
+ for _idx, frame in enumerate(container.decode(**stream_name)):
+ frames[frame.pts] = frame
+ if frame.pts >= end_offset:
+ if should_buffer and buffer_count < max_buffer_size:
+ buffer_count += 1
+ continue
+ break
+ except av.AVError:
+ # TODO add a warning
+ pass
+ # ensure that the results are sorted wrt the pts
+ result = [frames[i] for i in sorted(frames) if start_offset <= frames[i].pts <= end_offset]
+ if len(frames) > 0 and start_offset > 0 and start_offset not in frames:
+ # if there is no frame that exactly matches the pts of start_offset
+ # add the last frame smaller than start_offset, to guarantee that
+ # we will have all the necessary data. This is most useful for audio
+ preceding_frames = [i for i in frames if i < start_offset]
+ if len(preceding_frames) > 0:
+ first_frame_pts = max(preceding_frames)
+ result.insert(0, frames[first_frame_pts])
+ return result
+
+
+def _align_audio_frames(
+ aframes: torch.Tensor, audio_frames: List["av.frame.Frame"], ref_start: int, ref_end: float
+) -> torch.Tensor:
+ start, end = audio_frames[0].pts, audio_frames[-1].pts
+ total_aframes = aframes.shape[1]
+ step_per_aframe = (end - start + 1) / total_aframes
+ s_idx = 0
+ e_idx = total_aframes
+ if start < ref_start:
+ s_idx = int((ref_start - start) / step_per_aframe)
+ if end > ref_end:
+ e_idx = int((ref_end - end) / step_per_aframe)
+ return aframes[:, s_idx:e_idx]
+
+
+def read_video(
+ filename: str,
+ start_pts: Union[float, Fraction] = 0,
+ end_pts: Optional[Union[float, Fraction]] = None,
+ pts_unit: str = "pts",
+ output_format: str = "THWC",
+) -> Tuple[torch.Tensor, torch.Tensor, Dict[str, Any]]:
+ """
+ Reads a video from a file, returning both the video frames and the audio frames
+
+ Args:
+ filename (str): path to the video file
+ start_pts (int if pts_unit = 'pts', float / Fraction if pts_unit = 'sec', optional):
+ The start presentation time of the video
+ end_pts (int if pts_unit = 'pts', float / Fraction if pts_unit = 'sec', optional):
+ The end presentation time
+ pts_unit (str, optional): unit in which start_pts and end_pts values will be interpreted,
+ either 'pts' or 'sec'. Defaults to 'pts'.
+ output_format (str, optional): The format of the output video tensors. Can be either "THWC" (default) or "TCHW".
+
+ Returns:
+ vframes (Tensor[T, H, W, C] or Tensor[T, C, H, W]): the `T` video frames
+ aframes (Tensor[K, L]): the audio frames, where `K` is the number of channels and `L` is the number of points
+ info (Dict): metadata for the video and audio. Can contain the fields video_fps (float) and audio_fps (int)
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(read_video)
+
+ output_format = output_format.upper()
+ if output_format not in ("THWC", "TCHW"):
+ raise ValueError(f"output_format should be either 'THWC' or 'TCHW', got {output_format}.")
+
+ from torchvision import get_video_backend
+
+ if not os.path.exists(filename):
+ raise RuntimeError(f"File not found: {filename}")
+
+ if get_video_backend() != "pyav":
+ vframes, aframes, info = _video_opt._read_video(filename, start_pts, end_pts, pts_unit)
+ else:
+ _check_av_available()
+
+ if end_pts is None:
+ end_pts = float("inf")
+
+ if end_pts < start_pts:
+ raise ValueError(
+ f"end_pts should be larger than start_pts, got start_pts={start_pts} and end_pts={end_pts}"
+ )
+
+ info = {}
+ video_frames = []
+ audio_frames = []
+ audio_timebase = _video_opt.default_timebase
+
+ try:
+ with av.open(filename, metadata_errors="ignore") as container:
+ if container.streams.audio:
+ audio_timebase = container.streams.audio[0].time_base
+ if container.streams.video:
+ video_frames = _read_from_stream(
+ container,
+ start_pts,
+ end_pts,
+ pts_unit,
+ container.streams.video[0],
+ {"video": 0},
+ )
+ video_fps = container.streams.video[0].average_rate
+ # guard against potentially corrupted files
+ if video_fps is not None:
+ info["video_fps"] = float(video_fps)
+
+ if container.streams.audio:
+ audio_frames = _read_from_stream(
+ container,
+ start_pts,
+ end_pts,
+ pts_unit,
+ container.streams.audio[0],
+ {"audio": 0},
+ )
+ info["audio_fps"] = container.streams.audio[0].rate
+
+ except av.AVError:
+ # TODO raise a warning?
+ pass
+
+ vframes_list = [frame.to_rgb().to_ndarray() for frame in video_frames]
+ aframes_list = [frame.to_ndarray() for frame in audio_frames]
+
+ if vframes_list:
+ vframes = torch.as_tensor(np.stack(vframes_list))
+ else:
+ vframes = torch.empty((0, 1, 1, 3), dtype=torch.uint8)
+
+ if aframes_list:
+ aframes = np.concatenate(aframes_list, 1)
+ aframes = torch.as_tensor(aframes)
+ if pts_unit == "sec":
+ start_pts = int(math.floor(start_pts * (1 / audio_timebase)))
+ if end_pts != float("inf"):
+ end_pts = int(math.ceil(end_pts * (1 / audio_timebase)))
+ aframes = _align_audio_frames(aframes, audio_frames, start_pts, end_pts)
+ else:
+ aframes = torch.empty((1, 0), dtype=torch.float32)
+
+ if output_format == "TCHW":
+ # [T,H,W,C] --> [T,C,H,W]
+ vframes = vframes.permute(0, 3, 1, 2)
+
+ return vframes, aframes, info
+
+
+def _can_read_timestamps_from_packets(container: "av.container.Container") -> bool:
+ extradata = container.streams[0].codec_context.extradata
+ if extradata is None:
+ return False
+ if b"Lavc" in extradata:
+ return True
+ return False
+
+
+def _decode_video_timestamps(container: "av.container.Container") -> List[int]:
+ if _can_read_timestamps_from_packets(container):
+ # fast path
+ return [x.pts for x in container.demux(video=0) if x.pts is not None]
+ else:
+ return [x.pts for x in container.decode(video=0) if x.pts is not None]
+
+
+def read_video_timestamps(filename: str, pts_unit: str = "pts") -> Tuple[List[int], Optional[float]]:
+ """
+ List the video frames timestamps.
+
+ Note that the function decodes the whole video frame-by-frame.
+
+ Args:
+ filename (str): path to the video file
+ pts_unit (str, optional): unit in which timestamp values will be returned
+ either 'pts' or 'sec'. Defaults to 'pts'.
+
+ Returns:
+ pts (List[int] if pts_unit = 'pts', List[Fraction] if pts_unit = 'sec'):
+ presentation timestamps for each one of the frames in the video.
+ video_fps (float, optional): the frame rate for the video
+
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(read_video_timestamps)
+ from torchvision import get_video_backend
+
+ if get_video_backend() != "pyav":
+ return _video_opt._read_video_timestamps(filename, pts_unit)
+
+ _check_av_available()
+
+ video_fps = None
+ pts = []
+
+ try:
+ with av.open(filename, metadata_errors="ignore") as container:
+ if container.streams.video:
+ video_stream = container.streams.video[0]
+ video_time_base = video_stream.time_base
+ try:
+ pts = _decode_video_timestamps(container)
+ except av.AVError:
+ warnings.warn(f"Failed decoding frames for file {filename}")
+ video_fps = float(video_stream.average_rate)
+ except av.AVError as e:
+ msg = f"Failed to open container for {filename}; Caught error: {e}"
+ warnings.warn(msg, RuntimeWarning)
+
+ pts.sort()
+
+ if pts_unit == "sec":
+ pts = [x * video_time_base for x in pts]
+
+ return pts, video_fps
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/_api.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/_api.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b4b388eaa47e1889e35d67e1f0ed78e255d93c5c
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/_api.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/_meta.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/_meta.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3e137b47e8c6105e0614990d99d2cf046b758642
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/_meta.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/alexnet.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/alexnet.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d835a066219c9eeb97e2282868b5c267395df0e5
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/alexnet.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/feature_extraction.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/feature_extraction.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b0542cec038fcdfb0387f703e3b09e0f70a34cd7
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/feature_extraction.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/mnasnet.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/mnasnet.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7fe241eca79560766e26a30245d4b855859f95d4
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/mnasnet.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/shufflenetv2.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/shufflenetv2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..a2670e88158c2d979e241b5cca85a30789f25079
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/__pycache__/shufflenetv2.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/_meta.py b/wemm/lib/python3.10/site-packages/torchvision/models/_meta.py
new file mode 100644
index 0000000000000000000000000000000000000000..e66f411c287e0f456448315ba4fd0bfcce281d2b
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/_meta.py
@@ -0,0 +1,1554 @@
+"""
+This file is part of the private API. Please do not refer to any variables defined here directly as they will be
+removed on future versions without warning.
+"""
+
+# This will eventually be replaced with a call at torchvision.datasets.info("imagenet").categories
+_IMAGENET_CATEGORIES = [
+ "tench",
+ "goldfish",
+ "great white shark",
+ "tiger shark",
+ "hammerhead",
+ "electric ray",
+ "stingray",
+ "cock",
+ "hen",
+ "ostrich",
+ "brambling",
+ "goldfinch",
+ "house finch",
+ "junco",
+ "indigo bunting",
+ "robin",
+ "bulbul",
+ "jay",
+ "magpie",
+ "chickadee",
+ "water ouzel",
+ "kite",
+ "bald eagle",
+ "vulture",
+ "great grey owl",
+ "European fire salamander",
+ "common newt",
+ "eft",
+ "spotted salamander",
+ "axolotl",
+ "bullfrog",
+ "tree frog",
+ "tailed frog",
+ "loggerhead",
+ "leatherback turtle",
+ "mud turtle",
+ "terrapin",
+ "box turtle",
+ "banded gecko",
+ "common iguana",
+ "American chameleon",
+ "whiptail",
+ "agama",
+ "frilled lizard",
+ "alligator lizard",
+ "Gila monster",
+ "green lizard",
+ "African chameleon",
+ "Komodo dragon",
+ "African crocodile",
+ "American alligator",
+ "triceratops",
+ "thunder snake",
+ "ringneck snake",
+ "hognose snake",
+ "green snake",
+ "king snake",
+ "garter snake",
+ "water snake",
+ "vine snake",
+ "night snake",
+ "boa constrictor",
+ "rock python",
+ "Indian cobra",
+ "green mamba",
+ "sea snake",
+ "horned viper",
+ "diamondback",
+ "sidewinder",
+ "trilobite",
+ "harvestman",
+ "scorpion",
+ "black and gold garden spider",
+ "barn spider",
+ "garden spider",
+ "black widow",
+ "tarantula",
+ "wolf spider",
+ "tick",
+ "centipede",
+ "black grouse",
+ "ptarmigan",
+ "ruffed grouse",
+ "prairie chicken",
+ "peacock",
+ "quail",
+ "partridge",
+ "African grey",
+ "macaw",
+ "sulphur-crested cockatoo",
+ "lorikeet",
+ "coucal",
+ "bee eater",
+ "hornbill",
+ "hummingbird",
+ "jacamar",
+ "toucan",
+ "drake",
+ "red-breasted merganser",
+ "goose",
+ "black swan",
+ "tusker",
+ "echidna",
+ "platypus",
+ "wallaby",
+ "koala",
+ "wombat",
+ "jellyfish",
+ "sea anemone",
+ "brain coral",
+ "flatworm",
+ "nematode",
+ "conch",
+ "snail",
+ "slug",
+ "sea slug",
+ "chiton",
+ "chambered nautilus",
+ "Dungeness crab",
+ "rock crab",
+ "fiddler crab",
+ "king crab",
+ "American lobster",
+ "spiny lobster",
+ "crayfish",
+ "hermit crab",
+ "isopod",
+ "white stork",
+ "black stork",
+ "spoonbill",
+ "flamingo",
+ "little blue heron",
+ "American egret",
+ "bittern",
+ "crane bird",
+ "limpkin",
+ "European gallinule",
+ "American coot",
+ "bustard",
+ "ruddy turnstone",
+ "red-backed sandpiper",
+ "redshank",
+ "dowitcher",
+ "oystercatcher",
+ "pelican",
+ "king penguin",
+ "albatross",
+ "grey whale",
+ "killer whale",
+ "dugong",
+ "sea lion",
+ "Chihuahua",
+ "Japanese spaniel",
+ "Maltese dog",
+ "Pekinese",
+ "Shih-Tzu",
+ "Blenheim spaniel",
+ "papillon",
+ "toy terrier",
+ "Rhodesian ridgeback",
+ "Afghan hound",
+ "basset",
+ "beagle",
+ "bloodhound",
+ "bluetick",
+ "black-and-tan coonhound",
+ "Walker hound",
+ "English foxhound",
+ "redbone",
+ "borzoi",
+ "Irish wolfhound",
+ "Italian greyhound",
+ "whippet",
+ "Ibizan hound",
+ "Norwegian elkhound",
+ "otterhound",
+ "Saluki",
+ "Scottish deerhound",
+ "Weimaraner",
+ "Staffordshire bullterrier",
+ "American Staffordshire terrier",
+ "Bedlington terrier",
+ "Border terrier",
+ "Kerry blue terrier",
+ "Irish terrier",
+ "Norfolk terrier",
+ "Norwich terrier",
+ "Yorkshire terrier",
+ "wire-haired fox terrier",
+ "Lakeland terrier",
+ "Sealyham terrier",
+ "Airedale",
+ "cairn",
+ "Australian terrier",
+ "Dandie Dinmont",
+ "Boston bull",
+ "miniature schnauzer",
+ "giant schnauzer",
+ "standard schnauzer",
+ "Scotch terrier",
+ "Tibetan terrier",
+ "silky terrier",
+ "soft-coated wheaten terrier",
+ "West Highland white terrier",
+ "Lhasa",
+ "flat-coated retriever",
+ "curly-coated retriever",
+ "golden retriever",
+ "Labrador retriever",
+ "Chesapeake Bay retriever",
+ "German short-haired pointer",
+ "vizsla",
+ "English setter",
+ "Irish setter",
+ "Gordon setter",
+ "Brittany spaniel",
+ "clumber",
+ "English springer",
+ "Welsh springer spaniel",
+ "cocker spaniel",
+ "Sussex spaniel",
+ "Irish water spaniel",
+ "kuvasz",
+ "schipperke",
+ "groenendael",
+ "malinois",
+ "briard",
+ "kelpie",
+ "komondor",
+ "Old English sheepdog",
+ "Shetland sheepdog",
+ "collie",
+ "Border collie",
+ "Bouvier des Flandres",
+ "Rottweiler",
+ "German shepherd",
+ "Doberman",
+ "miniature pinscher",
+ "Greater Swiss Mountain dog",
+ "Bernese mountain dog",
+ "Appenzeller",
+ "EntleBucher",
+ "boxer",
+ "bull mastiff",
+ "Tibetan mastiff",
+ "French bulldog",
+ "Great Dane",
+ "Saint Bernard",
+ "Eskimo dog",
+ "malamute",
+ "Siberian husky",
+ "dalmatian",
+ "affenpinscher",
+ "basenji",
+ "pug",
+ "Leonberg",
+ "Newfoundland",
+ "Great Pyrenees",
+ "Samoyed",
+ "Pomeranian",
+ "chow",
+ "keeshond",
+ "Brabancon griffon",
+ "Pembroke",
+ "Cardigan",
+ "toy poodle",
+ "miniature poodle",
+ "standard poodle",
+ "Mexican hairless",
+ "timber wolf",
+ "white wolf",
+ "red wolf",
+ "coyote",
+ "dingo",
+ "dhole",
+ "African hunting dog",
+ "hyena",
+ "red fox",
+ "kit fox",
+ "Arctic fox",
+ "grey fox",
+ "tabby",
+ "tiger cat",
+ "Persian cat",
+ "Siamese cat",
+ "Egyptian cat",
+ "cougar",
+ "lynx",
+ "leopard",
+ "snow leopard",
+ "jaguar",
+ "lion",
+ "tiger",
+ "cheetah",
+ "brown bear",
+ "American black bear",
+ "ice bear",
+ "sloth bear",
+ "mongoose",
+ "meerkat",
+ "tiger beetle",
+ "ladybug",
+ "ground beetle",
+ "long-horned beetle",
+ "leaf beetle",
+ "dung beetle",
+ "rhinoceros beetle",
+ "weevil",
+ "fly",
+ "bee",
+ "ant",
+ "grasshopper",
+ "cricket",
+ "walking stick",
+ "cockroach",
+ "mantis",
+ "cicada",
+ "leafhopper",
+ "lacewing",
+ "dragonfly",
+ "damselfly",
+ "admiral",
+ "ringlet",
+ "monarch",
+ "cabbage butterfly",
+ "sulphur butterfly",
+ "lycaenid",
+ "starfish",
+ "sea urchin",
+ "sea cucumber",
+ "wood rabbit",
+ "hare",
+ "Angora",
+ "hamster",
+ "porcupine",
+ "fox squirrel",
+ "marmot",
+ "beaver",
+ "guinea pig",
+ "sorrel",
+ "zebra",
+ "hog",
+ "wild boar",
+ "warthog",
+ "hippopotamus",
+ "ox",
+ "water buffalo",
+ "bison",
+ "ram",
+ "bighorn",
+ "ibex",
+ "hartebeest",
+ "impala",
+ "gazelle",
+ "Arabian camel",
+ "llama",
+ "weasel",
+ "mink",
+ "polecat",
+ "black-footed ferret",
+ "otter",
+ "skunk",
+ "badger",
+ "armadillo",
+ "three-toed sloth",
+ "orangutan",
+ "gorilla",
+ "chimpanzee",
+ "gibbon",
+ "siamang",
+ "guenon",
+ "patas",
+ "baboon",
+ "macaque",
+ "langur",
+ "colobus",
+ "proboscis monkey",
+ "marmoset",
+ "capuchin",
+ "howler monkey",
+ "titi",
+ "spider monkey",
+ "squirrel monkey",
+ "Madagascar cat",
+ "indri",
+ "Indian elephant",
+ "African elephant",
+ "lesser panda",
+ "giant panda",
+ "barracouta",
+ "eel",
+ "coho",
+ "rock beauty",
+ "anemone fish",
+ "sturgeon",
+ "gar",
+ "lionfish",
+ "puffer",
+ "abacus",
+ "abaya",
+ "academic gown",
+ "accordion",
+ "acoustic guitar",
+ "aircraft carrier",
+ "airliner",
+ "airship",
+ "altar",
+ "ambulance",
+ "amphibian",
+ "analog clock",
+ "apiary",
+ "apron",
+ "ashcan",
+ "assault rifle",
+ "backpack",
+ "bakery",
+ "balance beam",
+ "balloon",
+ "ballpoint",
+ "Band Aid",
+ "banjo",
+ "bannister",
+ "barbell",
+ "barber chair",
+ "barbershop",
+ "barn",
+ "barometer",
+ "barrel",
+ "barrow",
+ "baseball",
+ "basketball",
+ "bassinet",
+ "bassoon",
+ "bathing cap",
+ "bath towel",
+ "bathtub",
+ "beach wagon",
+ "beacon",
+ "beaker",
+ "bearskin",
+ "beer bottle",
+ "beer glass",
+ "bell cote",
+ "bib",
+ "bicycle-built-for-two",
+ "bikini",
+ "binder",
+ "binoculars",
+ "birdhouse",
+ "boathouse",
+ "bobsled",
+ "bolo tie",
+ "bonnet",
+ "bookcase",
+ "bookshop",
+ "bottlecap",
+ "bow",
+ "bow tie",
+ "brass",
+ "brassiere",
+ "breakwater",
+ "breastplate",
+ "broom",
+ "bucket",
+ "buckle",
+ "bulletproof vest",
+ "bullet train",
+ "butcher shop",
+ "cab",
+ "caldron",
+ "candle",
+ "cannon",
+ "canoe",
+ "can opener",
+ "cardigan",
+ "car mirror",
+ "carousel",
+ "carpenter's kit",
+ "carton",
+ "car wheel",
+ "cash machine",
+ "cassette",
+ "cassette player",
+ "castle",
+ "catamaran",
+ "CD player",
+ "cello",
+ "cellular telephone",
+ "chain",
+ "chainlink fence",
+ "chain mail",
+ "chain saw",
+ "chest",
+ "chiffonier",
+ "chime",
+ "china cabinet",
+ "Christmas stocking",
+ "church",
+ "cinema",
+ "cleaver",
+ "cliff dwelling",
+ "cloak",
+ "clog",
+ "cocktail shaker",
+ "coffee mug",
+ "coffeepot",
+ "coil",
+ "combination lock",
+ "computer keyboard",
+ "confectionery",
+ "container ship",
+ "convertible",
+ "corkscrew",
+ "cornet",
+ "cowboy boot",
+ "cowboy hat",
+ "cradle",
+ "crane",
+ "crash helmet",
+ "crate",
+ "crib",
+ "Crock Pot",
+ "croquet ball",
+ "crutch",
+ "cuirass",
+ "dam",
+ "desk",
+ "desktop computer",
+ "dial telephone",
+ "diaper",
+ "digital clock",
+ "digital watch",
+ "dining table",
+ "dishrag",
+ "dishwasher",
+ "disk brake",
+ "dock",
+ "dogsled",
+ "dome",
+ "doormat",
+ "drilling platform",
+ "drum",
+ "drumstick",
+ "dumbbell",
+ "Dutch oven",
+ "electric fan",
+ "electric guitar",
+ "electric locomotive",
+ "entertainment center",
+ "envelope",
+ "espresso maker",
+ "face powder",
+ "feather boa",
+ "file",
+ "fireboat",
+ "fire engine",
+ "fire screen",
+ "flagpole",
+ "flute",
+ "folding chair",
+ "football helmet",
+ "forklift",
+ "fountain",
+ "fountain pen",
+ "four-poster",
+ "freight car",
+ "French horn",
+ "frying pan",
+ "fur coat",
+ "garbage truck",
+ "gasmask",
+ "gas pump",
+ "goblet",
+ "go-kart",
+ "golf ball",
+ "golfcart",
+ "gondola",
+ "gong",
+ "gown",
+ "grand piano",
+ "greenhouse",
+ "grille",
+ "grocery store",
+ "guillotine",
+ "hair slide",
+ "hair spray",
+ "half track",
+ "hammer",
+ "hamper",
+ "hand blower",
+ "hand-held computer",
+ "handkerchief",
+ "hard disc",
+ "harmonica",
+ "harp",
+ "harvester",
+ "hatchet",
+ "holster",
+ "home theater",
+ "honeycomb",
+ "hook",
+ "hoopskirt",
+ "horizontal bar",
+ "horse cart",
+ "hourglass",
+ "iPod",
+ "iron",
+ "jack-o'-lantern",
+ "jean",
+ "jeep",
+ "jersey",
+ "jigsaw puzzle",
+ "jinrikisha",
+ "joystick",
+ "kimono",
+ "knee pad",
+ "knot",
+ "lab coat",
+ "ladle",
+ "lampshade",
+ "laptop",
+ "lawn mower",
+ "lens cap",
+ "letter opener",
+ "library",
+ "lifeboat",
+ "lighter",
+ "limousine",
+ "liner",
+ "lipstick",
+ "Loafer",
+ "lotion",
+ "loudspeaker",
+ "loupe",
+ "lumbermill",
+ "magnetic compass",
+ "mailbag",
+ "mailbox",
+ "maillot",
+ "maillot tank suit",
+ "manhole cover",
+ "maraca",
+ "marimba",
+ "mask",
+ "matchstick",
+ "maypole",
+ "maze",
+ "measuring cup",
+ "medicine chest",
+ "megalith",
+ "microphone",
+ "microwave",
+ "military uniform",
+ "milk can",
+ "minibus",
+ "miniskirt",
+ "minivan",
+ "missile",
+ "mitten",
+ "mixing bowl",
+ "mobile home",
+ "Model T",
+ "modem",
+ "monastery",
+ "monitor",
+ "moped",
+ "mortar",
+ "mortarboard",
+ "mosque",
+ "mosquito net",
+ "motor scooter",
+ "mountain bike",
+ "mountain tent",
+ "mouse",
+ "mousetrap",
+ "moving van",
+ "muzzle",
+ "nail",
+ "neck brace",
+ "necklace",
+ "nipple",
+ "notebook",
+ "obelisk",
+ "oboe",
+ "ocarina",
+ "odometer",
+ "oil filter",
+ "organ",
+ "oscilloscope",
+ "overskirt",
+ "oxcart",
+ "oxygen mask",
+ "packet",
+ "paddle",
+ "paddlewheel",
+ "padlock",
+ "paintbrush",
+ "pajama",
+ "palace",
+ "panpipe",
+ "paper towel",
+ "parachute",
+ "parallel bars",
+ "park bench",
+ "parking meter",
+ "passenger car",
+ "patio",
+ "pay-phone",
+ "pedestal",
+ "pencil box",
+ "pencil sharpener",
+ "perfume",
+ "Petri dish",
+ "photocopier",
+ "pick",
+ "pickelhaube",
+ "picket fence",
+ "pickup",
+ "pier",
+ "piggy bank",
+ "pill bottle",
+ "pillow",
+ "ping-pong ball",
+ "pinwheel",
+ "pirate",
+ "pitcher",
+ "plane",
+ "planetarium",
+ "plastic bag",
+ "plate rack",
+ "plow",
+ "plunger",
+ "Polaroid camera",
+ "pole",
+ "police van",
+ "poncho",
+ "pool table",
+ "pop bottle",
+ "pot",
+ "potter's wheel",
+ "power drill",
+ "prayer rug",
+ "printer",
+ "prison",
+ "projectile",
+ "projector",
+ "puck",
+ "punching bag",
+ "purse",
+ "quill",
+ "quilt",
+ "racer",
+ "racket",
+ "radiator",
+ "radio",
+ "radio telescope",
+ "rain barrel",
+ "recreational vehicle",
+ "reel",
+ "reflex camera",
+ "refrigerator",
+ "remote control",
+ "restaurant",
+ "revolver",
+ "rifle",
+ "rocking chair",
+ "rotisserie",
+ "rubber eraser",
+ "rugby ball",
+ "rule",
+ "running shoe",
+ "safe",
+ "safety pin",
+ "saltshaker",
+ "sandal",
+ "sarong",
+ "sax",
+ "scabbard",
+ "scale",
+ "school bus",
+ "schooner",
+ "scoreboard",
+ "screen",
+ "screw",
+ "screwdriver",
+ "seat belt",
+ "sewing machine",
+ "shield",
+ "shoe shop",
+ "shoji",
+ "shopping basket",
+ "shopping cart",
+ "shovel",
+ "shower cap",
+ "shower curtain",
+ "ski",
+ "ski mask",
+ "sleeping bag",
+ "slide rule",
+ "sliding door",
+ "slot",
+ "snorkel",
+ "snowmobile",
+ "snowplow",
+ "soap dispenser",
+ "soccer ball",
+ "sock",
+ "solar dish",
+ "sombrero",
+ "soup bowl",
+ "space bar",
+ "space heater",
+ "space shuttle",
+ "spatula",
+ "speedboat",
+ "spider web",
+ "spindle",
+ "sports car",
+ "spotlight",
+ "stage",
+ "steam locomotive",
+ "steel arch bridge",
+ "steel drum",
+ "stethoscope",
+ "stole",
+ "stone wall",
+ "stopwatch",
+ "stove",
+ "strainer",
+ "streetcar",
+ "stretcher",
+ "studio couch",
+ "stupa",
+ "submarine",
+ "suit",
+ "sundial",
+ "sunglass",
+ "sunglasses",
+ "sunscreen",
+ "suspension bridge",
+ "swab",
+ "sweatshirt",
+ "swimming trunks",
+ "swing",
+ "switch",
+ "syringe",
+ "table lamp",
+ "tank",
+ "tape player",
+ "teapot",
+ "teddy",
+ "television",
+ "tennis ball",
+ "thatch",
+ "theater curtain",
+ "thimble",
+ "thresher",
+ "throne",
+ "tile roof",
+ "toaster",
+ "tobacco shop",
+ "toilet seat",
+ "torch",
+ "totem pole",
+ "tow truck",
+ "toyshop",
+ "tractor",
+ "trailer truck",
+ "tray",
+ "trench coat",
+ "tricycle",
+ "trimaran",
+ "tripod",
+ "triumphal arch",
+ "trolleybus",
+ "trombone",
+ "tub",
+ "turnstile",
+ "typewriter keyboard",
+ "umbrella",
+ "unicycle",
+ "upright",
+ "vacuum",
+ "vase",
+ "vault",
+ "velvet",
+ "vending machine",
+ "vestment",
+ "viaduct",
+ "violin",
+ "volleyball",
+ "waffle iron",
+ "wall clock",
+ "wallet",
+ "wardrobe",
+ "warplane",
+ "washbasin",
+ "washer",
+ "water bottle",
+ "water jug",
+ "water tower",
+ "whiskey jug",
+ "whistle",
+ "wig",
+ "window screen",
+ "window shade",
+ "Windsor tie",
+ "wine bottle",
+ "wing",
+ "wok",
+ "wooden spoon",
+ "wool",
+ "worm fence",
+ "wreck",
+ "yawl",
+ "yurt",
+ "web site",
+ "comic book",
+ "crossword puzzle",
+ "street sign",
+ "traffic light",
+ "book jacket",
+ "menu",
+ "plate",
+ "guacamole",
+ "consomme",
+ "hot pot",
+ "trifle",
+ "ice cream",
+ "ice lolly",
+ "French loaf",
+ "bagel",
+ "pretzel",
+ "cheeseburger",
+ "hotdog",
+ "mashed potato",
+ "head cabbage",
+ "broccoli",
+ "cauliflower",
+ "zucchini",
+ "spaghetti squash",
+ "acorn squash",
+ "butternut squash",
+ "cucumber",
+ "artichoke",
+ "bell pepper",
+ "cardoon",
+ "mushroom",
+ "Granny Smith",
+ "strawberry",
+ "orange",
+ "lemon",
+ "fig",
+ "pineapple",
+ "banana",
+ "jackfruit",
+ "custard apple",
+ "pomegranate",
+ "hay",
+ "carbonara",
+ "chocolate sauce",
+ "dough",
+ "meat loaf",
+ "pizza",
+ "potpie",
+ "burrito",
+ "red wine",
+ "espresso",
+ "cup",
+ "eggnog",
+ "alp",
+ "bubble",
+ "cliff",
+ "coral reef",
+ "geyser",
+ "lakeside",
+ "promontory",
+ "sandbar",
+ "seashore",
+ "valley",
+ "volcano",
+ "ballplayer",
+ "groom",
+ "scuba diver",
+ "rapeseed",
+ "daisy",
+ "yellow lady's slipper",
+ "corn",
+ "acorn",
+ "hip",
+ "buckeye",
+ "coral fungus",
+ "agaric",
+ "gyromitra",
+ "stinkhorn",
+ "earthstar",
+ "hen-of-the-woods",
+ "bolete",
+ "ear",
+ "toilet tissue",
+]
+
+# To be replaced with torchvision.datasets.info("coco").categories
+_COCO_CATEGORIES = [
+ "__background__",
+ "person",
+ "bicycle",
+ "car",
+ "motorcycle",
+ "airplane",
+ "bus",
+ "train",
+ "truck",
+ "boat",
+ "traffic light",
+ "fire hydrant",
+ "N/A",
+ "stop sign",
+ "parking meter",
+ "bench",
+ "bird",
+ "cat",
+ "dog",
+ "horse",
+ "sheep",
+ "cow",
+ "elephant",
+ "bear",
+ "zebra",
+ "giraffe",
+ "N/A",
+ "backpack",
+ "umbrella",
+ "N/A",
+ "N/A",
+ "handbag",
+ "tie",
+ "suitcase",
+ "frisbee",
+ "skis",
+ "snowboard",
+ "sports ball",
+ "kite",
+ "baseball bat",
+ "baseball glove",
+ "skateboard",
+ "surfboard",
+ "tennis racket",
+ "bottle",
+ "N/A",
+ "wine glass",
+ "cup",
+ "fork",
+ "knife",
+ "spoon",
+ "bowl",
+ "banana",
+ "apple",
+ "sandwich",
+ "orange",
+ "broccoli",
+ "carrot",
+ "hot dog",
+ "pizza",
+ "donut",
+ "cake",
+ "chair",
+ "couch",
+ "potted plant",
+ "bed",
+ "N/A",
+ "dining table",
+ "N/A",
+ "N/A",
+ "toilet",
+ "N/A",
+ "tv",
+ "laptop",
+ "mouse",
+ "remote",
+ "keyboard",
+ "cell phone",
+ "microwave",
+ "oven",
+ "toaster",
+ "sink",
+ "refrigerator",
+ "N/A",
+ "book",
+ "clock",
+ "vase",
+ "scissors",
+ "teddy bear",
+ "hair drier",
+ "toothbrush",
+]
+
+# To be replaced with torchvision.datasets.info("coco_kp")
+_COCO_PERSON_CATEGORIES = ["no person", "person"]
+_COCO_PERSON_KEYPOINT_NAMES = [
+ "nose",
+ "left_eye",
+ "right_eye",
+ "left_ear",
+ "right_ear",
+ "left_shoulder",
+ "right_shoulder",
+ "left_elbow",
+ "right_elbow",
+ "left_wrist",
+ "right_wrist",
+ "left_hip",
+ "right_hip",
+ "left_knee",
+ "right_knee",
+ "left_ankle",
+ "right_ankle",
+]
+
+# To be replaced with torchvision.datasets.info("voc").categories
+_VOC_CATEGORIES = [
+ "__background__",
+ "aeroplane",
+ "bicycle",
+ "bird",
+ "boat",
+ "bottle",
+ "bus",
+ "car",
+ "cat",
+ "chair",
+ "cow",
+ "diningtable",
+ "dog",
+ "horse",
+ "motorbike",
+ "person",
+ "pottedplant",
+ "sheep",
+ "sofa",
+ "train",
+ "tvmonitor",
+]
+
+# To be replaced with torchvision.datasets.info("kinetics400").categories
+_KINETICS400_CATEGORIES = [
+ "abseiling",
+ "air drumming",
+ "answering questions",
+ "applauding",
+ "applying cream",
+ "archery",
+ "arm wrestling",
+ "arranging flowers",
+ "assembling computer",
+ "auctioning",
+ "baby waking up",
+ "baking cookies",
+ "balloon blowing",
+ "bandaging",
+ "barbequing",
+ "bartending",
+ "beatboxing",
+ "bee keeping",
+ "belly dancing",
+ "bench pressing",
+ "bending back",
+ "bending metal",
+ "biking through snow",
+ "blasting sand",
+ "blowing glass",
+ "blowing leaves",
+ "blowing nose",
+ "blowing out candles",
+ "bobsledding",
+ "bookbinding",
+ "bouncing on trampoline",
+ "bowling",
+ "braiding hair",
+ "breading or breadcrumbing",
+ "breakdancing",
+ "brush painting",
+ "brushing hair",
+ "brushing teeth",
+ "building cabinet",
+ "building shed",
+ "bungee jumping",
+ "busking",
+ "canoeing or kayaking",
+ "capoeira",
+ "carrying baby",
+ "cartwheeling",
+ "carving pumpkin",
+ "catching fish",
+ "catching or throwing baseball",
+ "catching or throwing frisbee",
+ "catching or throwing softball",
+ "celebrating",
+ "changing oil",
+ "changing wheel",
+ "checking tires",
+ "cheerleading",
+ "chopping wood",
+ "clapping",
+ "clay pottery making",
+ "clean and jerk",
+ "cleaning floor",
+ "cleaning gutters",
+ "cleaning pool",
+ "cleaning shoes",
+ "cleaning toilet",
+ "cleaning windows",
+ "climbing a rope",
+ "climbing ladder",
+ "climbing tree",
+ "contact juggling",
+ "cooking chicken",
+ "cooking egg",
+ "cooking on campfire",
+ "cooking sausages",
+ "counting money",
+ "country line dancing",
+ "cracking neck",
+ "crawling baby",
+ "crossing river",
+ "crying",
+ "curling hair",
+ "cutting nails",
+ "cutting pineapple",
+ "cutting watermelon",
+ "dancing ballet",
+ "dancing charleston",
+ "dancing gangnam style",
+ "dancing macarena",
+ "deadlifting",
+ "decorating the christmas tree",
+ "digging",
+ "dining",
+ "disc golfing",
+ "diving cliff",
+ "dodgeball",
+ "doing aerobics",
+ "doing laundry",
+ "doing nails",
+ "drawing",
+ "dribbling basketball",
+ "drinking",
+ "drinking beer",
+ "drinking shots",
+ "driving car",
+ "driving tractor",
+ "drop kicking",
+ "drumming fingers",
+ "dunking basketball",
+ "dying hair",
+ "eating burger",
+ "eating cake",
+ "eating carrots",
+ "eating chips",
+ "eating doughnuts",
+ "eating hotdog",
+ "eating ice cream",
+ "eating spaghetti",
+ "eating watermelon",
+ "egg hunting",
+ "exercising arm",
+ "exercising with an exercise ball",
+ "extinguishing fire",
+ "faceplanting",
+ "feeding birds",
+ "feeding fish",
+ "feeding goats",
+ "filling eyebrows",
+ "finger snapping",
+ "fixing hair",
+ "flipping pancake",
+ "flying kite",
+ "folding clothes",
+ "folding napkins",
+ "folding paper",
+ "front raises",
+ "frying vegetables",
+ "garbage collecting",
+ "gargling",
+ "getting a haircut",
+ "getting a tattoo",
+ "giving or receiving award",
+ "golf chipping",
+ "golf driving",
+ "golf putting",
+ "grinding meat",
+ "grooming dog",
+ "grooming horse",
+ "gymnastics tumbling",
+ "hammer throw",
+ "headbanging",
+ "headbutting",
+ "high jump",
+ "high kick",
+ "hitting baseball",
+ "hockey stop",
+ "holding snake",
+ "hopscotch",
+ "hoverboarding",
+ "hugging",
+ "hula hooping",
+ "hurdling",
+ "hurling (sport)",
+ "ice climbing",
+ "ice fishing",
+ "ice skating",
+ "ironing",
+ "javelin throw",
+ "jetskiing",
+ "jogging",
+ "juggling balls",
+ "juggling fire",
+ "juggling soccer ball",
+ "jumping into pool",
+ "jumpstyle dancing",
+ "kicking field goal",
+ "kicking soccer ball",
+ "kissing",
+ "kitesurfing",
+ "knitting",
+ "krumping",
+ "laughing",
+ "laying bricks",
+ "long jump",
+ "lunge",
+ "making a cake",
+ "making a sandwich",
+ "making bed",
+ "making jewelry",
+ "making pizza",
+ "making snowman",
+ "making sushi",
+ "making tea",
+ "marching",
+ "massaging back",
+ "massaging feet",
+ "massaging legs",
+ "massaging person's head",
+ "milking cow",
+ "mopping floor",
+ "motorcycling",
+ "moving furniture",
+ "mowing lawn",
+ "news anchoring",
+ "opening bottle",
+ "opening present",
+ "paragliding",
+ "parasailing",
+ "parkour",
+ "passing American football (in game)",
+ "passing American football (not in game)",
+ "peeling apples",
+ "peeling potatoes",
+ "petting animal (not cat)",
+ "petting cat",
+ "picking fruit",
+ "planting trees",
+ "plastering",
+ "playing accordion",
+ "playing badminton",
+ "playing bagpipes",
+ "playing basketball",
+ "playing bass guitar",
+ "playing cards",
+ "playing cello",
+ "playing chess",
+ "playing clarinet",
+ "playing controller",
+ "playing cricket",
+ "playing cymbals",
+ "playing didgeridoo",
+ "playing drums",
+ "playing flute",
+ "playing guitar",
+ "playing harmonica",
+ "playing harp",
+ "playing ice hockey",
+ "playing keyboard",
+ "playing kickball",
+ "playing monopoly",
+ "playing organ",
+ "playing paintball",
+ "playing piano",
+ "playing poker",
+ "playing recorder",
+ "playing saxophone",
+ "playing squash or racquetball",
+ "playing tennis",
+ "playing trombone",
+ "playing trumpet",
+ "playing ukulele",
+ "playing violin",
+ "playing volleyball",
+ "playing xylophone",
+ "pole vault",
+ "presenting weather forecast",
+ "pull ups",
+ "pumping fist",
+ "pumping gas",
+ "punching bag",
+ "punching person (boxing)",
+ "push up",
+ "pushing car",
+ "pushing cart",
+ "pushing wheelchair",
+ "reading book",
+ "reading newspaper",
+ "recording music",
+ "riding a bike",
+ "riding camel",
+ "riding elephant",
+ "riding mechanical bull",
+ "riding mountain bike",
+ "riding mule",
+ "riding or walking with horse",
+ "riding scooter",
+ "riding unicycle",
+ "ripping paper",
+ "robot dancing",
+ "rock climbing",
+ "rock scissors paper",
+ "roller skating",
+ "running on treadmill",
+ "sailing",
+ "salsa dancing",
+ "sanding floor",
+ "scrambling eggs",
+ "scuba diving",
+ "setting table",
+ "shaking hands",
+ "shaking head",
+ "sharpening knives",
+ "sharpening pencil",
+ "shaving head",
+ "shaving legs",
+ "shearing sheep",
+ "shining shoes",
+ "shooting basketball",
+ "shooting goal (soccer)",
+ "shot put",
+ "shoveling snow",
+ "shredding paper",
+ "shuffling cards",
+ "side kick",
+ "sign language interpreting",
+ "singing",
+ "situp",
+ "skateboarding",
+ "ski jumping",
+ "skiing (not slalom or crosscountry)",
+ "skiing crosscountry",
+ "skiing slalom",
+ "skipping rope",
+ "skydiving",
+ "slacklining",
+ "slapping",
+ "sled dog racing",
+ "smoking",
+ "smoking hookah",
+ "snatch weight lifting",
+ "sneezing",
+ "sniffing",
+ "snorkeling",
+ "snowboarding",
+ "snowkiting",
+ "snowmobiling",
+ "somersaulting",
+ "spinning poi",
+ "spray painting",
+ "spraying",
+ "springboard diving",
+ "squat",
+ "sticking tongue out",
+ "stomping grapes",
+ "stretching arm",
+ "stretching leg",
+ "strumming guitar",
+ "surfing crowd",
+ "surfing water",
+ "sweeping floor",
+ "swimming backstroke",
+ "swimming breast stroke",
+ "swimming butterfly stroke",
+ "swing dancing",
+ "swinging legs",
+ "swinging on something",
+ "sword fighting",
+ "tai chi",
+ "taking a shower",
+ "tango dancing",
+ "tap dancing",
+ "tapping guitar",
+ "tapping pen",
+ "tasting beer",
+ "tasting food",
+ "testifying",
+ "texting",
+ "throwing axe",
+ "throwing ball",
+ "throwing discus",
+ "tickling",
+ "tobogganing",
+ "tossing coin",
+ "tossing salad",
+ "training dog",
+ "trapezing",
+ "trimming or shaving beard",
+ "trimming trees",
+ "triple jump",
+ "tying bow tie",
+ "tying knot (not on a tie)",
+ "tying tie",
+ "unboxing",
+ "unloading truck",
+ "using computer",
+ "using remote controller (not gaming)",
+ "using segway",
+ "vault",
+ "waiting in line",
+ "walking the dog",
+ "washing dishes",
+ "washing feet",
+ "washing hair",
+ "washing hands",
+ "water skiing",
+ "water sliding",
+ "watering plants",
+ "waxing back",
+ "waxing chest",
+ "waxing eyebrows",
+ "waxing legs",
+ "weaving basket",
+ "welding",
+ "whistling",
+ "windsurfing",
+ "wrapping present",
+ "wrestling",
+ "writing",
+ "yawning",
+ "yoga",
+ "zumba",
+]
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/densenet.py b/wemm/lib/python3.10/site-packages/torchvision/models/densenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..8253b9572b41cbb50bdd502147531d75bc94ff35
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/densenet.py
@@ -0,0 +1,448 @@
+import re
+from collections import OrderedDict
+from functools import partial
+from typing import Any, List, Optional, Tuple
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.utils.checkpoint as cp
+from torch import Tensor
+
+from ..transforms._presets import ImageClassification
+from ..utils import _log_api_usage_once
+from ._api import register_model, Weights, WeightsEnum
+from ._meta import _IMAGENET_CATEGORIES
+from ._utils import _ovewrite_named_param, handle_legacy_interface
+
+__all__ = [
+ "DenseNet",
+ "DenseNet121_Weights",
+ "DenseNet161_Weights",
+ "DenseNet169_Weights",
+ "DenseNet201_Weights",
+ "densenet121",
+ "densenet161",
+ "densenet169",
+ "densenet201",
+]
+
+
+class _DenseLayer(nn.Module):
+ def __init__(
+ self, num_input_features: int, growth_rate: int, bn_size: int, drop_rate: float, memory_efficient: bool = False
+ ) -> None:
+ super().__init__()
+ self.norm1 = nn.BatchNorm2d(num_input_features)
+ self.relu1 = nn.ReLU(inplace=True)
+ self.conv1 = nn.Conv2d(num_input_features, bn_size * growth_rate, kernel_size=1, stride=1, bias=False)
+
+ self.norm2 = nn.BatchNorm2d(bn_size * growth_rate)
+ self.relu2 = nn.ReLU(inplace=True)
+ self.conv2 = nn.Conv2d(bn_size * growth_rate, growth_rate, kernel_size=3, stride=1, padding=1, bias=False)
+
+ self.drop_rate = float(drop_rate)
+ self.memory_efficient = memory_efficient
+
+ def bn_function(self, inputs: List[Tensor]) -> Tensor:
+ concated_features = torch.cat(inputs, 1)
+ bottleneck_output = self.conv1(self.relu1(self.norm1(concated_features))) # noqa: T484
+ return bottleneck_output
+
+ # todo: rewrite when torchscript supports any
+ def any_requires_grad(self, input: List[Tensor]) -> bool:
+ for tensor in input:
+ if tensor.requires_grad:
+ return True
+ return False
+
+ @torch.jit.unused # noqa: T484
+ def call_checkpoint_bottleneck(self, input: List[Tensor]) -> Tensor:
+ def closure(*inputs):
+ return self.bn_function(inputs)
+
+ return cp.checkpoint(closure, *input)
+
+ @torch.jit._overload_method # noqa: F811
+ def forward(self, input: List[Tensor]) -> Tensor: # noqa: F811
+ pass
+
+ @torch.jit._overload_method # noqa: F811
+ def forward(self, input: Tensor) -> Tensor: # noqa: F811
+ pass
+
+ # torchscript does not yet support *args, so we overload method
+ # allowing it to take either a List[Tensor] or single Tensor
+ def forward(self, input: Tensor) -> Tensor: # noqa: F811
+ if isinstance(input, Tensor):
+ prev_features = [input]
+ else:
+ prev_features = input
+
+ if self.memory_efficient and self.any_requires_grad(prev_features):
+ if torch.jit.is_scripting():
+ raise Exception("Memory Efficient not supported in JIT")
+
+ bottleneck_output = self.call_checkpoint_bottleneck(prev_features)
+ else:
+ bottleneck_output = self.bn_function(prev_features)
+
+ new_features = self.conv2(self.relu2(self.norm2(bottleneck_output)))
+ if self.drop_rate > 0:
+ new_features = F.dropout(new_features, p=self.drop_rate, training=self.training)
+ return new_features
+
+
+class _DenseBlock(nn.ModuleDict):
+ _version = 2
+
+ def __init__(
+ self,
+ num_layers: int,
+ num_input_features: int,
+ bn_size: int,
+ growth_rate: int,
+ drop_rate: float,
+ memory_efficient: bool = False,
+ ) -> None:
+ super().__init__()
+ for i in range(num_layers):
+ layer = _DenseLayer(
+ num_input_features + i * growth_rate,
+ growth_rate=growth_rate,
+ bn_size=bn_size,
+ drop_rate=drop_rate,
+ memory_efficient=memory_efficient,
+ )
+ self.add_module("denselayer%d" % (i + 1), layer)
+
+ def forward(self, init_features: Tensor) -> Tensor:
+ features = [init_features]
+ for name, layer in self.items():
+ new_features = layer(features)
+ features.append(new_features)
+ return torch.cat(features, 1)
+
+
+class _Transition(nn.Sequential):
+ def __init__(self, num_input_features: int, num_output_features: int) -> None:
+ super().__init__()
+ self.norm = nn.BatchNorm2d(num_input_features)
+ self.relu = nn.ReLU(inplace=True)
+ self.conv = nn.Conv2d(num_input_features, num_output_features, kernel_size=1, stride=1, bias=False)
+ self.pool = nn.AvgPool2d(kernel_size=2, stride=2)
+
+
+class DenseNet(nn.Module):
+ r"""Densenet-BC model class, based on
+ `"Densely Connected Convolutional Networks" `_.
+
+ Args:
+ growth_rate (int) - how many filters to add each layer (`k` in paper)
+ block_config (list of 4 ints) - how many layers in each pooling block
+ num_init_features (int) - the number of filters to learn in the first convolution layer
+ bn_size (int) - multiplicative factor for number of bottle neck layers
+ (i.e. bn_size * k features in the bottleneck layer)
+ drop_rate (float) - dropout rate after each dense layer
+ num_classes (int) - number of classification classes
+ memory_efficient (bool) - If True, uses checkpointing. Much more memory efficient,
+ but slower. Default: *False*. See `"paper" `_.
+ """
+
+ def __init__(
+ self,
+ growth_rate: int = 32,
+ block_config: Tuple[int, int, int, int] = (6, 12, 24, 16),
+ num_init_features: int = 64,
+ bn_size: int = 4,
+ drop_rate: float = 0,
+ num_classes: int = 1000,
+ memory_efficient: bool = False,
+ ) -> None:
+
+ super().__init__()
+ _log_api_usage_once(self)
+
+ # First convolution
+ self.features = nn.Sequential(
+ OrderedDict(
+ [
+ ("conv0", nn.Conv2d(3, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)),
+ ("norm0", nn.BatchNorm2d(num_init_features)),
+ ("relu0", nn.ReLU(inplace=True)),
+ ("pool0", nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
+ ]
+ )
+ )
+
+ # Each denseblock
+ num_features = num_init_features
+ for i, num_layers in enumerate(block_config):
+ block = _DenseBlock(
+ num_layers=num_layers,
+ num_input_features=num_features,
+ bn_size=bn_size,
+ growth_rate=growth_rate,
+ drop_rate=drop_rate,
+ memory_efficient=memory_efficient,
+ )
+ self.features.add_module("denseblock%d" % (i + 1), block)
+ num_features = num_features + num_layers * growth_rate
+ if i != len(block_config) - 1:
+ trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
+ self.features.add_module("transition%d" % (i + 1), trans)
+ num_features = num_features // 2
+
+ # Final batch norm
+ self.features.add_module("norm5", nn.BatchNorm2d(num_features))
+
+ # Linear layer
+ self.classifier = nn.Linear(num_features, num_classes)
+
+ # Official init from torch repo.
+ for m in self.modules():
+ if isinstance(m, nn.Conv2d):
+ nn.init.kaiming_normal_(m.weight)
+ elif isinstance(m, nn.BatchNorm2d):
+ nn.init.constant_(m.weight, 1)
+ nn.init.constant_(m.bias, 0)
+ elif isinstance(m, nn.Linear):
+ nn.init.constant_(m.bias, 0)
+
+ def forward(self, x: Tensor) -> Tensor:
+ features = self.features(x)
+ out = F.relu(features, inplace=True)
+ out = F.adaptive_avg_pool2d(out, (1, 1))
+ out = torch.flatten(out, 1)
+ out = self.classifier(out)
+ return out
+
+
+def _load_state_dict(model: nn.Module, weights: WeightsEnum, progress: bool) -> None:
+ # '.'s are no longer allowed in module names, but previous _DenseLayer
+ # has keys 'norm.1', 'relu.1', 'conv.1', 'norm.2', 'relu.2', 'conv.2'.
+ # They are also in the checkpoints in model_urls. This pattern is used
+ # to find such keys.
+ pattern = re.compile(
+ r"^(.*denselayer\d+\.(?:norm|relu|conv))\.((?:[12])\.(?:weight|bias|running_mean|running_var))$"
+ )
+
+ state_dict = weights.get_state_dict(progress=progress)
+ for key in list(state_dict.keys()):
+ res = pattern.match(key)
+ if res:
+ new_key = res.group(1) + res.group(2)
+ state_dict[new_key] = state_dict[key]
+ del state_dict[key]
+ model.load_state_dict(state_dict)
+
+
+def _densenet(
+ growth_rate: int,
+ block_config: Tuple[int, int, int, int],
+ num_init_features: int,
+ weights: Optional[WeightsEnum],
+ progress: bool,
+ **kwargs: Any,
+) -> DenseNet:
+ if weights is not None:
+ _ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"]))
+
+ model = DenseNet(growth_rate, block_config, num_init_features, **kwargs)
+
+ if weights is not None:
+ _load_state_dict(model=model, weights=weights, progress=progress)
+
+ return model
+
+
+_COMMON_META = {
+ "min_size": (29, 29),
+ "categories": _IMAGENET_CATEGORIES,
+ "recipe": "https://github.com/pytorch/vision/pull/116",
+ "_docs": """These weights are ported from LuaTorch.""",
+}
+
+
+class DenseNet121_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/densenet121-a639ec97.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 7978856,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 74.434,
+ "acc@5": 91.972,
+ }
+ },
+ "_ops": 2.834,
+ "_file_size": 30.845,
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+class DenseNet161_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/densenet161-8d451a50.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 28681000,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 77.138,
+ "acc@5": 93.560,
+ }
+ },
+ "_ops": 7.728,
+ "_file_size": 110.369,
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+class DenseNet169_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/densenet169-b2777c0a.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 14149480,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 75.600,
+ "acc@5": 92.806,
+ }
+ },
+ "_ops": 3.36,
+ "_file_size": 54.708,
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+class DenseNet201_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/densenet201-c1103571.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 20013928,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 76.896,
+ "acc@5": 93.370,
+ }
+ },
+ "_ops": 4.291,
+ "_file_size": 77.373,
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", DenseNet121_Weights.IMAGENET1K_V1))
+def densenet121(*, weights: Optional[DenseNet121_Weights] = None, progress: bool = True, **kwargs: Any) -> DenseNet:
+ r"""Densenet-121 model from
+ `Densely Connected Convolutional Networks `_.
+
+ Args:
+ weights (:class:`~torchvision.models.DenseNet121_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.DenseNet121_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.densenet.DenseNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.DenseNet121_Weights
+ :members:
+ """
+ weights = DenseNet121_Weights.verify(weights)
+
+ return _densenet(32, (6, 12, 24, 16), 64, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", DenseNet161_Weights.IMAGENET1K_V1))
+def densenet161(*, weights: Optional[DenseNet161_Weights] = None, progress: bool = True, **kwargs: Any) -> DenseNet:
+ r"""Densenet-161 model from
+ `Densely Connected Convolutional Networks `_.
+
+ Args:
+ weights (:class:`~torchvision.models.DenseNet161_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.DenseNet161_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.densenet.DenseNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.DenseNet161_Weights
+ :members:
+ """
+ weights = DenseNet161_Weights.verify(weights)
+
+ return _densenet(48, (6, 12, 36, 24), 96, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", DenseNet169_Weights.IMAGENET1K_V1))
+def densenet169(*, weights: Optional[DenseNet169_Weights] = None, progress: bool = True, **kwargs: Any) -> DenseNet:
+ r"""Densenet-169 model from
+ `Densely Connected Convolutional Networks `_.
+
+ Args:
+ weights (:class:`~torchvision.models.DenseNet169_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.DenseNet169_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.densenet.DenseNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.DenseNet169_Weights
+ :members:
+ """
+ weights = DenseNet169_Weights.verify(weights)
+
+ return _densenet(32, (6, 12, 32, 32), 64, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", DenseNet201_Weights.IMAGENET1K_V1))
+def densenet201(*, weights: Optional[DenseNet201_Weights] = None, progress: bool = True, **kwargs: Any) -> DenseNet:
+ r"""Densenet-201 model from
+ `Densely Connected Convolutional Networks `_.
+
+ Args:
+ weights (:class:`~torchvision.models.DenseNet201_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.DenseNet201_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.densenet.DenseNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.DenseNet201_Weights
+ :members:
+ """
+ weights = DenseNet201_Weights.verify(weights)
+
+ return _densenet(32, (6, 12, 48, 32), 64, weights, progress, **kwargs)
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/__init__.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..fca4cd115a70f295f38a52132e52e43218476068
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/__init__.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/anchor_utils.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/anchor_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cbc0a1faab75ca6164c7b801f12f4f7b8d1a2afb
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/anchor_utils.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/backbone_utils.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/backbone_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b2e028a9b89fb674b7bdccc5681c5768fd9ae6bb
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/backbone_utils.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/image_list.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/image_list.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..c8437584f5eb877bfe2535f7d24c1ff455f65762
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/image_list.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/mask_rcnn.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/mask_rcnn.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..02d8ed35a76b16cad0ce749b01b2fa6f39fb3738
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/mask_rcnn.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/transform.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/transform.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..884eeb262cace627ab709eb8b05b40ef30ddd93e
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/detection/__pycache__/transform.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/_utils.py b/wemm/lib/python3.10/site-packages/torchvision/models/detection/_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..a25bdc1d42c482e54462fdc07afad867763a1fe5
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/detection/_utils.py
@@ -0,0 +1,548 @@
+import math
+from collections import OrderedDict
+from typing import Dict, List, Optional, Tuple
+
+import torch
+from torch import nn, Tensor
+from torch.nn import functional as F
+from torchvision.ops import complete_box_iou_loss, distance_box_iou_loss, FrozenBatchNorm2d, generalized_box_iou_loss
+
+
+class BalancedPositiveNegativeSampler:
+ """
+ This class samples batches, ensuring that they contain a fixed proportion of positives
+ """
+
+ def __init__(self, batch_size_per_image: int, positive_fraction: float) -> None:
+ """
+ Args:
+ batch_size_per_image (int): number of elements to be selected per image
+ positive_fraction (float): percentage of positive elements per batch
+ """
+ self.batch_size_per_image = batch_size_per_image
+ self.positive_fraction = positive_fraction
+
+ def __call__(self, matched_idxs: List[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
+ """
+ Args:
+ matched_idxs: list of tensors containing -1, 0 or positive values.
+ Each tensor corresponds to a specific image.
+ -1 values are ignored, 0 are considered as negatives and > 0 as
+ positives.
+
+ Returns:
+ pos_idx (list[tensor])
+ neg_idx (list[tensor])
+
+ Returns two lists of binary masks for each image.
+ The first list contains the positive elements that were selected,
+ and the second list the negative example.
+ """
+ pos_idx = []
+ neg_idx = []
+ for matched_idxs_per_image in matched_idxs:
+ positive = torch.where(matched_idxs_per_image >= 1)[0]
+ negative = torch.where(matched_idxs_per_image == 0)[0]
+
+ num_pos = int(self.batch_size_per_image * self.positive_fraction)
+ # protect against not enough positive examples
+ num_pos = min(positive.numel(), num_pos)
+ num_neg = self.batch_size_per_image - num_pos
+ # protect against not enough negative examples
+ num_neg = min(negative.numel(), num_neg)
+
+ # randomly select positive and negative examples
+ perm1 = torch.randperm(positive.numel(), device=positive.device)[:num_pos]
+ perm2 = torch.randperm(negative.numel(), device=negative.device)[:num_neg]
+
+ pos_idx_per_image = positive[perm1]
+ neg_idx_per_image = negative[perm2]
+
+ # create binary mask from indices
+ pos_idx_per_image_mask = torch.zeros_like(matched_idxs_per_image, dtype=torch.uint8)
+ neg_idx_per_image_mask = torch.zeros_like(matched_idxs_per_image, dtype=torch.uint8)
+
+ pos_idx_per_image_mask[pos_idx_per_image] = 1
+ neg_idx_per_image_mask[neg_idx_per_image] = 1
+
+ pos_idx.append(pos_idx_per_image_mask)
+ neg_idx.append(neg_idx_per_image_mask)
+
+ return pos_idx, neg_idx
+
+
+@torch.jit._script_if_tracing
+def encode_boxes(reference_boxes: Tensor, proposals: Tensor, weights: Tensor) -> Tensor:
+ """
+ Encode a set of proposals with respect to some
+ reference boxes
+
+ Args:
+ reference_boxes (Tensor): reference boxes
+ proposals (Tensor): boxes to be encoded
+ weights (Tensor[4]): the weights for ``(x, y, w, h)``
+ """
+
+ # perform some unpacking to make it JIT-fusion friendly
+ wx = weights[0]
+ wy = weights[1]
+ ww = weights[2]
+ wh = weights[3]
+
+ proposals_x1 = proposals[:, 0].unsqueeze(1)
+ proposals_y1 = proposals[:, 1].unsqueeze(1)
+ proposals_x2 = proposals[:, 2].unsqueeze(1)
+ proposals_y2 = proposals[:, 3].unsqueeze(1)
+
+ reference_boxes_x1 = reference_boxes[:, 0].unsqueeze(1)
+ reference_boxes_y1 = reference_boxes[:, 1].unsqueeze(1)
+ reference_boxes_x2 = reference_boxes[:, 2].unsqueeze(1)
+ reference_boxes_y2 = reference_boxes[:, 3].unsqueeze(1)
+
+ # implementation starts here
+ ex_widths = proposals_x2 - proposals_x1
+ ex_heights = proposals_y2 - proposals_y1
+ ex_ctr_x = proposals_x1 + 0.5 * ex_widths
+ ex_ctr_y = proposals_y1 + 0.5 * ex_heights
+
+ gt_widths = reference_boxes_x2 - reference_boxes_x1
+ gt_heights = reference_boxes_y2 - reference_boxes_y1
+ gt_ctr_x = reference_boxes_x1 + 0.5 * gt_widths
+ gt_ctr_y = reference_boxes_y1 + 0.5 * gt_heights
+
+ targets_dx = wx * (gt_ctr_x - ex_ctr_x) / ex_widths
+ targets_dy = wy * (gt_ctr_y - ex_ctr_y) / ex_heights
+ targets_dw = ww * torch.log(gt_widths / ex_widths)
+ targets_dh = wh * torch.log(gt_heights / ex_heights)
+
+ targets = torch.cat((targets_dx, targets_dy, targets_dw, targets_dh), dim=1)
+ return targets
+
+
+class BoxCoder:
+ """
+ This class encodes and decodes a set of bounding boxes into
+ the representation used for training the regressors.
+ """
+
+ def __init__(
+ self, weights: Tuple[float, float, float, float], bbox_xform_clip: float = math.log(1000.0 / 16)
+ ) -> None:
+ """
+ Args:
+ weights (4-element tuple)
+ bbox_xform_clip (float)
+ """
+ self.weights = weights
+ self.bbox_xform_clip = bbox_xform_clip
+
+ def encode(self, reference_boxes: List[Tensor], proposals: List[Tensor]) -> List[Tensor]:
+ boxes_per_image = [len(b) for b in reference_boxes]
+ reference_boxes = torch.cat(reference_boxes, dim=0)
+ proposals = torch.cat(proposals, dim=0)
+ targets = self.encode_single(reference_boxes, proposals)
+ return targets.split(boxes_per_image, 0)
+
+ def encode_single(self, reference_boxes: Tensor, proposals: Tensor) -> Tensor:
+ """
+ Encode a set of proposals with respect to some
+ reference boxes
+
+ Args:
+ reference_boxes (Tensor): reference boxes
+ proposals (Tensor): boxes to be encoded
+ """
+ dtype = reference_boxes.dtype
+ device = reference_boxes.device
+ weights = torch.as_tensor(self.weights, dtype=dtype, device=device)
+ targets = encode_boxes(reference_boxes, proposals, weights)
+
+ return targets
+
+ def decode(self, rel_codes: Tensor, boxes: List[Tensor]) -> Tensor:
+ torch._assert(
+ isinstance(boxes, (list, tuple)),
+ "This function expects boxes of type list or tuple.",
+ )
+ torch._assert(
+ isinstance(rel_codes, torch.Tensor),
+ "This function expects rel_codes of type torch.Tensor.",
+ )
+ boxes_per_image = [b.size(0) for b in boxes]
+ concat_boxes = torch.cat(boxes, dim=0)
+ box_sum = 0
+ for val in boxes_per_image:
+ box_sum += val
+ if box_sum > 0:
+ rel_codes = rel_codes.reshape(box_sum, -1)
+ pred_boxes = self.decode_single(rel_codes, concat_boxes)
+ if box_sum > 0:
+ pred_boxes = pred_boxes.reshape(box_sum, -1, 4)
+ return pred_boxes
+
+ def decode_single(self, rel_codes: Tensor, boxes: Tensor) -> Tensor:
+ """
+ From a set of original boxes and encoded relative box offsets,
+ get the decoded boxes.
+
+ Args:
+ rel_codes (Tensor): encoded boxes
+ boxes (Tensor): reference boxes.
+ """
+
+ boxes = boxes.to(rel_codes.dtype)
+
+ widths = boxes[:, 2] - boxes[:, 0]
+ heights = boxes[:, 3] - boxes[:, 1]
+ ctr_x = boxes[:, 0] + 0.5 * widths
+ ctr_y = boxes[:, 1] + 0.5 * heights
+
+ wx, wy, ww, wh = self.weights
+ dx = rel_codes[:, 0::4] / wx
+ dy = rel_codes[:, 1::4] / wy
+ dw = rel_codes[:, 2::4] / ww
+ dh = rel_codes[:, 3::4] / wh
+
+ # Prevent sending too large values into torch.exp()
+ dw = torch.clamp(dw, max=self.bbox_xform_clip)
+ dh = torch.clamp(dh, max=self.bbox_xform_clip)
+
+ pred_ctr_x = dx * widths[:, None] + ctr_x[:, None]
+ pred_ctr_y = dy * heights[:, None] + ctr_y[:, None]
+ pred_w = torch.exp(dw) * widths[:, None]
+ pred_h = torch.exp(dh) * heights[:, None]
+
+ # Distance from center to box's corner.
+ c_to_c_h = torch.tensor(0.5, dtype=pred_ctr_y.dtype, device=pred_h.device) * pred_h
+ c_to_c_w = torch.tensor(0.5, dtype=pred_ctr_x.dtype, device=pred_w.device) * pred_w
+
+ pred_boxes1 = pred_ctr_x - c_to_c_w
+ pred_boxes2 = pred_ctr_y - c_to_c_h
+ pred_boxes3 = pred_ctr_x + c_to_c_w
+ pred_boxes4 = pred_ctr_y + c_to_c_h
+ pred_boxes = torch.stack((pred_boxes1, pred_boxes2, pred_boxes3, pred_boxes4), dim=2).flatten(1)
+ return pred_boxes
+
+
+class BoxLinearCoder:
+ """
+ The linear box-to-box transform defined in FCOS. The transformation is parameterized
+ by the distance from the center of (square) src box to 4 edges of the target box.
+ """
+
+ def __init__(self, normalize_by_size: bool = True) -> None:
+ """
+ Args:
+ normalize_by_size (bool): normalize deltas by the size of src (anchor) boxes.
+ """
+ self.normalize_by_size = normalize_by_size
+
+ def encode(self, reference_boxes: Tensor, proposals: Tensor) -> Tensor:
+ """
+ Encode a set of proposals with respect to some reference boxes
+
+ Args:
+ reference_boxes (Tensor): reference boxes
+ proposals (Tensor): boxes to be encoded
+
+ Returns:
+ Tensor: the encoded relative box offsets that can be used to
+ decode the boxes.
+
+ """
+
+ # get the center of reference_boxes
+ reference_boxes_ctr_x = 0.5 * (reference_boxes[..., 0] + reference_boxes[..., 2])
+ reference_boxes_ctr_y = 0.5 * (reference_boxes[..., 1] + reference_boxes[..., 3])
+
+ # get box regression transformation deltas
+ target_l = reference_boxes_ctr_x - proposals[..., 0]
+ target_t = reference_boxes_ctr_y - proposals[..., 1]
+ target_r = proposals[..., 2] - reference_boxes_ctr_x
+ target_b = proposals[..., 3] - reference_boxes_ctr_y
+
+ targets = torch.stack((target_l, target_t, target_r, target_b), dim=-1)
+
+ if self.normalize_by_size:
+ reference_boxes_w = reference_boxes[..., 2] - reference_boxes[..., 0]
+ reference_boxes_h = reference_boxes[..., 3] - reference_boxes[..., 1]
+ reference_boxes_size = torch.stack(
+ (reference_boxes_w, reference_boxes_h, reference_boxes_w, reference_boxes_h), dim=-1
+ )
+ targets = targets / reference_boxes_size
+ return targets
+
+ def decode(self, rel_codes: Tensor, boxes: Tensor) -> Tensor:
+
+ """
+ From a set of original boxes and encoded relative box offsets,
+ get the decoded boxes.
+
+ Args:
+ rel_codes (Tensor): encoded boxes
+ boxes (Tensor): reference boxes.
+
+ Returns:
+ Tensor: the predicted boxes with the encoded relative box offsets.
+
+ .. note::
+ This method assumes that ``rel_codes`` and ``boxes`` have same size for 0th dimension. i.e. ``len(rel_codes) == len(boxes)``.
+
+ """
+
+ boxes = boxes.to(dtype=rel_codes.dtype)
+
+ ctr_x = 0.5 * (boxes[..., 0] + boxes[..., 2])
+ ctr_y = 0.5 * (boxes[..., 1] + boxes[..., 3])
+
+ if self.normalize_by_size:
+ boxes_w = boxes[..., 2] - boxes[..., 0]
+ boxes_h = boxes[..., 3] - boxes[..., 1]
+
+ list_box_size = torch.stack((boxes_w, boxes_h, boxes_w, boxes_h), dim=-1)
+ rel_codes = rel_codes * list_box_size
+
+ pred_boxes1 = ctr_x - rel_codes[..., 0]
+ pred_boxes2 = ctr_y - rel_codes[..., 1]
+ pred_boxes3 = ctr_x + rel_codes[..., 2]
+ pred_boxes4 = ctr_y + rel_codes[..., 3]
+
+ pred_boxes = torch.stack((pred_boxes1, pred_boxes2, pred_boxes3, pred_boxes4), dim=-1)
+ return pred_boxes
+
+
+class Matcher:
+ """
+ This class assigns to each predicted "element" (e.g., a box) a ground-truth
+ element. Each predicted element will have exactly zero or one matches; each
+ ground-truth element may be assigned to zero or more predicted elements.
+
+ Matching is based on the MxN match_quality_matrix, that characterizes how well
+ each (ground-truth, predicted)-pair match. For example, if the elements are
+ boxes, the matrix may contain box IoU overlap values.
+
+ The matcher returns a tensor of size N containing the index of the ground-truth
+ element m that matches to prediction n. If there is no match, a negative value
+ is returned.
+ """
+
+ BELOW_LOW_THRESHOLD = -1
+ BETWEEN_THRESHOLDS = -2
+
+ __annotations__ = {
+ "BELOW_LOW_THRESHOLD": int,
+ "BETWEEN_THRESHOLDS": int,
+ }
+
+ def __init__(self, high_threshold: float, low_threshold: float, allow_low_quality_matches: bool = False) -> None:
+ """
+ Args:
+ high_threshold (float): quality values greater than or equal to
+ this value are candidate matches.
+ low_threshold (float): a lower quality threshold used to stratify
+ matches into three levels:
+ 1) matches >= high_threshold
+ 2) BETWEEN_THRESHOLDS matches in [low_threshold, high_threshold)
+ 3) BELOW_LOW_THRESHOLD matches in [0, low_threshold)
+ allow_low_quality_matches (bool): if True, produce additional matches
+ for predictions that have only low-quality match candidates. See
+ set_low_quality_matches_ for more details.
+ """
+ self.BELOW_LOW_THRESHOLD = -1
+ self.BETWEEN_THRESHOLDS = -2
+ torch._assert(low_threshold <= high_threshold, "low_threshold should be <= high_threshold")
+ self.high_threshold = high_threshold
+ self.low_threshold = low_threshold
+ self.allow_low_quality_matches = allow_low_quality_matches
+
+ def __call__(self, match_quality_matrix: Tensor) -> Tensor:
+ """
+ Args:
+ match_quality_matrix (Tensor[float]): an MxN tensor, containing the
+ pairwise quality between M ground-truth elements and N predicted elements.
+
+ Returns:
+ matches (Tensor[int64]): an N tensor where N[i] is a matched gt in
+ [0, M - 1] or a negative value indicating that prediction i could not
+ be matched.
+ """
+ if match_quality_matrix.numel() == 0:
+ # empty targets or proposals not supported during training
+ if match_quality_matrix.shape[0] == 0:
+ raise ValueError("No ground-truth boxes available for one of the images during training")
+ else:
+ raise ValueError("No proposal boxes available for one of the images during training")
+
+ # match_quality_matrix is M (gt) x N (predicted)
+ # Max over gt elements (dim 0) to find best gt candidate for each prediction
+ matched_vals, matches = match_quality_matrix.max(dim=0)
+ if self.allow_low_quality_matches:
+ all_matches = matches.clone()
+ else:
+ all_matches = None # type: ignore[assignment]
+
+ # Assign candidate matches with low quality to negative (unassigned) values
+ below_low_threshold = matched_vals < self.low_threshold
+ between_thresholds = (matched_vals >= self.low_threshold) & (matched_vals < self.high_threshold)
+ matches[below_low_threshold] = self.BELOW_LOW_THRESHOLD
+ matches[between_thresholds] = self.BETWEEN_THRESHOLDS
+
+ if self.allow_low_quality_matches:
+ if all_matches is None:
+ torch._assert(False, "all_matches should not be None")
+ else:
+ self.set_low_quality_matches_(matches, all_matches, match_quality_matrix)
+
+ return matches
+
+ def set_low_quality_matches_(self, matches: Tensor, all_matches: Tensor, match_quality_matrix: Tensor) -> None:
+ """
+ Produce additional matches for predictions that have only low-quality matches.
+ Specifically, for each ground-truth find the set of predictions that have
+ maximum overlap with it (including ties); for each prediction in that set, if
+ it is unmatched, then match it to the ground-truth with which it has the highest
+ quality value.
+ """
+ # For each gt, find the prediction with which it has the highest quality
+ highest_quality_foreach_gt, _ = match_quality_matrix.max(dim=1)
+ # Find the highest quality match available, even if it is low, including ties
+ gt_pred_pairs_of_highest_quality = torch.where(match_quality_matrix == highest_quality_foreach_gt[:, None])
+ # Example gt_pred_pairs_of_highest_quality:
+ # tensor([[ 0, 39796],
+ # [ 1, 32055],
+ # [ 1, 32070],
+ # [ 2, 39190],
+ # [ 2, 40255],
+ # [ 3, 40390],
+ # [ 3, 41455],
+ # [ 4, 45470],
+ # [ 5, 45325],
+ # [ 5, 46390]])
+ # Each row is a (gt index, prediction index)
+ # Note how gt items 1, 2, 3, and 5 each have two ties
+
+ pred_inds_to_update = gt_pred_pairs_of_highest_quality[1]
+ matches[pred_inds_to_update] = all_matches[pred_inds_to_update]
+
+
+class SSDMatcher(Matcher):
+ def __init__(self, threshold: float) -> None:
+ super().__init__(threshold, threshold, allow_low_quality_matches=False)
+
+ def __call__(self, match_quality_matrix: Tensor) -> Tensor:
+ matches = super().__call__(match_quality_matrix)
+
+ # For each gt, find the prediction with which it has the highest quality
+ _, highest_quality_pred_foreach_gt = match_quality_matrix.max(dim=1)
+ matches[highest_quality_pred_foreach_gt] = torch.arange(
+ highest_quality_pred_foreach_gt.size(0), dtype=torch.int64, device=highest_quality_pred_foreach_gt.device
+ )
+
+ return matches
+
+
+def overwrite_eps(model: nn.Module, eps: float) -> None:
+ """
+ This method overwrites the default eps values of all the
+ FrozenBatchNorm2d layers of the model with the provided value.
+ This is necessary to address the BC-breaking change introduced
+ by the bug-fix at pytorch/vision#2933. The overwrite is applied
+ only when the pretrained weights are loaded to maintain compatibility
+ with previous versions.
+
+ Args:
+ model (nn.Module): The model on which we perform the overwrite.
+ eps (float): The new value of eps.
+ """
+ for module in model.modules():
+ if isinstance(module, FrozenBatchNorm2d):
+ module.eps = eps
+
+
+def retrieve_out_channels(model: nn.Module, size: Tuple[int, int]) -> List[int]:
+ """
+ This method retrieves the number of output channels of a specific model.
+
+ Args:
+ model (nn.Module): The model for which we estimate the out_channels.
+ It should return a single Tensor or an OrderedDict[Tensor].
+ size (Tuple[int, int]): The size (wxh) of the input.
+
+ Returns:
+ out_channels (List[int]): A list of the output channels of the model.
+ """
+ in_training = model.training
+ model.eval()
+
+ with torch.no_grad():
+ # Use dummy data to retrieve the feature map sizes to avoid hard-coding their values
+ device = next(model.parameters()).device
+ tmp_img = torch.zeros((1, 3, size[1], size[0]), device=device)
+ features = model(tmp_img)
+ if isinstance(features, torch.Tensor):
+ features = OrderedDict([("0", features)])
+ out_channels = [x.size(1) for x in features.values()]
+
+ if in_training:
+ model.train()
+
+ return out_channels
+
+
+@torch.jit.unused
+def _fake_cast_onnx(v: Tensor) -> int:
+ return v # type: ignore[return-value]
+
+
+def _topk_min(input: Tensor, orig_kval: int, axis: int) -> int:
+ """
+ ONNX spec requires the k-value to be less than or equal to the number of inputs along
+ provided dim. Certain models use the number of elements along a particular axis instead of K
+ if K exceeds the number of elements along that axis. Previously, python's min() function was
+ used to determine whether to use the provided k-value or the specified dim axis value.
+
+ However, in cases where the model is being exported in tracing mode, python min() is
+ static causing the model to be traced incorrectly and eventually fail at the topk node.
+ In order to avoid this situation, in tracing mode, torch.min() is used instead.
+
+ Args:
+ input (Tensor): The original input tensor.
+ orig_kval (int): The provided k-value.
+ axis(int): Axis along which we retrieve the input size.
+
+ Returns:
+ min_kval (int): Appropriately selected k-value.
+ """
+ if not torch.jit.is_tracing():
+ return min(orig_kval, input.size(axis))
+ axis_dim_val = torch._shape_as_tensor(input)[axis].unsqueeze(0)
+ min_kval = torch.min(torch.cat((torch.tensor([orig_kval], dtype=axis_dim_val.dtype), axis_dim_val), 0))
+ return _fake_cast_onnx(min_kval)
+
+
+def _box_loss(
+ type: str,
+ box_coder: BoxCoder,
+ anchors_per_image: Tensor,
+ matched_gt_boxes_per_image: Tensor,
+ bbox_regression_per_image: Tensor,
+ cnf: Optional[Dict[str, float]] = None,
+) -> Tensor:
+ torch._assert(type in ["l1", "smooth_l1", "ciou", "diou", "giou"], f"Unsupported loss: {type}")
+
+ if type == "l1":
+ target_regression = box_coder.encode_single(matched_gt_boxes_per_image, anchors_per_image)
+ return F.l1_loss(bbox_regression_per_image, target_regression, reduction="sum")
+ elif type == "smooth_l1":
+ target_regression = box_coder.encode_single(matched_gt_boxes_per_image, anchors_per_image)
+ beta = cnf["beta"] if cnf is not None and "beta" in cnf else 1.0
+ return F.smooth_l1_loss(bbox_regression_per_image, target_regression, reduction="sum", beta=beta)
+ else:
+ bbox_per_image = box_coder.decode_single(bbox_regression_per_image, anchors_per_image)
+ eps = cnf["eps"] if cnf is not None and "eps" in cnf else 1e-7
+ if type == "ciou":
+ return complete_box_iou_loss(bbox_per_image, matched_gt_boxes_per_image, reduction="sum", eps=eps)
+ if type == "diou":
+ return distance_box_iou_loss(bbox_per_image, matched_gt_boxes_per_image, reduction="sum", eps=eps)
+ # otherwise giou
+ return generalized_box_iou_loss(bbox_per_image, matched_gt_boxes_per_image, reduction="sum", eps=eps)
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/backbone_utils.py b/wemm/lib/python3.10/site-packages/torchvision/models/detection/backbone_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..1b10961d33e95a4d1b259464490112fe7fa2fb70
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/detection/backbone_utils.py
@@ -0,0 +1,242 @@
+import warnings
+from typing import Callable, Dict, List, Optional, Union
+
+from torch import nn, Tensor
+from torchvision.ops import misc as misc_nn_ops
+from torchvision.ops.feature_pyramid_network import ExtraFPNBlock, FeaturePyramidNetwork, LastLevelMaxPool
+
+from .. import mobilenet, resnet
+from .._api import _get_enum_from_fn, WeightsEnum
+from .._utils import handle_legacy_interface, IntermediateLayerGetter
+
+
+class BackboneWithFPN(nn.Module):
+ """
+ Adds a FPN on top of a model.
+ Internally, it uses torchvision.models._utils.IntermediateLayerGetter to
+ extract a submodel that returns the feature maps specified in return_layers.
+ The same limitations of IntermediateLayerGetter apply here.
+ Args:
+ backbone (nn.Module)
+ return_layers (Dict[name, new_name]): a dict containing the names
+ of the modules for which the activations will be returned as
+ the key of the dict, and the value of the dict is the name
+ of the returned activation (which the user can specify).
+ in_channels_list (List[int]): number of channels for each feature map
+ that is returned, in the order they are present in the OrderedDict
+ out_channels (int): number of channels in the FPN.
+ norm_layer (callable, optional): Module specifying the normalization layer to use. Default: None
+ Attributes:
+ out_channels (int): the number of channels in the FPN
+ """
+
+ def __init__(
+ self,
+ backbone: nn.Module,
+ return_layers: Dict[str, str],
+ in_channels_list: List[int],
+ out_channels: int,
+ extra_blocks: Optional[ExtraFPNBlock] = None,
+ norm_layer: Optional[Callable[..., nn.Module]] = None,
+ ) -> None:
+ super().__init__()
+
+ if extra_blocks is None:
+ extra_blocks = LastLevelMaxPool()
+
+ self.body = IntermediateLayerGetter(backbone, return_layers=return_layers)
+ self.fpn = FeaturePyramidNetwork(
+ in_channels_list=in_channels_list,
+ out_channels=out_channels,
+ extra_blocks=extra_blocks,
+ norm_layer=norm_layer,
+ )
+ self.out_channels = out_channels
+
+ def forward(self, x: Tensor) -> Dict[str, Tensor]:
+ x = self.body(x)
+ x = self.fpn(x)
+ return x
+
+
+@handle_legacy_interface(
+ weights=(
+ "pretrained",
+ lambda kwargs: _get_enum_from_fn(resnet.__dict__[kwargs["backbone_name"]])["IMAGENET1K_V1"],
+ ),
+)
+def resnet_fpn_backbone(
+ *,
+ backbone_name: str,
+ weights: Optional[WeightsEnum],
+ norm_layer: Callable[..., nn.Module] = misc_nn_ops.FrozenBatchNorm2d,
+ trainable_layers: int = 3,
+ returned_layers: Optional[List[int]] = None,
+ extra_blocks: Optional[ExtraFPNBlock] = None,
+) -> BackboneWithFPN:
+ """
+ Constructs a specified ResNet backbone with FPN on top. Freezes the specified number of layers in the backbone.
+
+ Examples::
+
+ >>> from torchvision.models.detection.backbone_utils import resnet_fpn_backbone
+ >>> backbone = resnet_fpn_backbone('resnet50', weights=ResNet50_Weights.DEFAULT, trainable_layers=3)
+ >>> # get some dummy image
+ >>> x = torch.rand(1,3,64,64)
+ >>> # compute the output
+ >>> output = backbone(x)
+ >>> print([(k, v.shape) for k, v in output.items()])
+ >>> # returns
+ >>> [('0', torch.Size([1, 256, 16, 16])),
+ >>> ('1', torch.Size([1, 256, 8, 8])),
+ >>> ('2', torch.Size([1, 256, 4, 4])),
+ >>> ('3', torch.Size([1, 256, 2, 2])),
+ >>> ('pool', torch.Size([1, 256, 1, 1]))]
+
+ Args:
+ backbone_name (string): resnet architecture. Possible values are 'resnet18', 'resnet34', 'resnet50',
+ 'resnet101', 'resnet152', 'resnext50_32x4d', 'resnext101_32x8d', 'wide_resnet50_2', 'wide_resnet101_2'
+ weights (WeightsEnum, optional): The pretrained weights for the model
+ norm_layer (callable): it is recommended to use the default value. For details visit:
+ (https://github.com/facebookresearch/maskrcnn-benchmark/issues/267)
+ trainable_layers (int): number of trainable (not frozen) layers starting from final block.
+ Valid values are between 0 and 5, with 5 meaning all backbone layers are trainable.
+ returned_layers (list of int): The layers of the network to return. Each entry must be in ``[1, 4]``.
+ By default, all layers are returned.
+ extra_blocks (ExtraFPNBlock or None): if provided, extra operations will
+ be performed. It is expected to take the fpn features, the original
+ features and the names of the original features as input, and returns
+ a new list of feature maps and their corresponding names. By
+ default, a ``LastLevelMaxPool`` is used.
+ """
+ backbone = resnet.__dict__[backbone_name](weights=weights, norm_layer=norm_layer)
+ return _resnet_fpn_extractor(backbone, trainable_layers, returned_layers, extra_blocks)
+
+
+def _resnet_fpn_extractor(
+ backbone: resnet.ResNet,
+ trainable_layers: int,
+ returned_layers: Optional[List[int]] = None,
+ extra_blocks: Optional[ExtraFPNBlock] = None,
+ norm_layer: Optional[Callable[..., nn.Module]] = None,
+) -> BackboneWithFPN:
+
+ # select layers that won't be frozen
+ if trainable_layers < 0 or trainable_layers > 5:
+ raise ValueError(f"Trainable layers should be in the range [0,5], got {trainable_layers}")
+ layers_to_train = ["layer4", "layer3", "layer2", "layer1", "conv1"][:trainable_layers]
+ if trainable_layers == 5:
+ layers_to_train.append("bn1")
+ for name, parameter in backbone.named_parameters():
+ if all([not name.startswith(layer) for layer in layers_to_train]):
+ parameter.requires_grad_(False)
+
+ if extra_blocks is None:
+ extra_blocks = LastLevelMaxPool()
+
+ if returned_layers is None:
+ returned_layers = [1, 2, 3, 4]
+ if min(returned_layers) <= 0 or max(returned_layers) >= 5:
+ raise ValueError(f"Each returned layer should be in the range [1,4]. Got {returned_layers}")
+ return_layers = {f"layer{k}": str(v) for v, k in enumerate(returned_layers)}
+
+ in_channels_stage2 = backbone.inplanes // 8
+ in_channels_list = [in_channels_stage2 * 2 ** (i - 1) for i in returned_layers]
+ out_channels = 256
+ return BackboneWithFPN(
+ backbone, return_layers, in_channels_list, out_channels, extra_blocks=extra_blocks, norm_layer=norm_layer
+ )
+
+
+def _validate_trainable_layers(
+ is_trained: bool,
+ trainable_backbone_layers: Optional[int],
+ max_value: int,
+ default_value: int,
+) -> int:
+ # don't freeze any layers if pretrained model or backbone is not used
+ if not is_trained:
+ if trainable_backbone_layers is not None:
+ warnings.warn(
+ "Changing trainable_backbone_layers has not effect if "
+ "neither pretrained nor pretrained_backbone have been set to True, "
+ f"falling back to trainable_backbone_layers={max_value} so that all layers are trainable"
+ )
+ trainable_backbone_layers = max_value
+
+ # by default freeze first blocks
+ if trainable_backbone_layers is None:
+ trainable_backbone_layers = default_value
+ if trainable_backbone_layers < 0 or trainable_backbone_layers > max_value:
+ raise ValueError(
+ f"Trainable backbone layers should be in the range [0,{max_value}], got {trainable_backbone_layers} "
+ )
+ return trainable_backbone_layers
+
+
+@handle_legacy_interface(
+ weights=(
+ "pretrained",
+ lambda kwargs: _get_enum_from_fn(mobilenet.__dict__[kwargs["backbone_name"]])["IMAGENET1K_V1"],
+ ),
+)
+def mobilenet_backbone(
+ *,
+ backbone_name: str,
+ weights: Optional[WeightsEnum],
+ fpn: bool,
+ norm_layer: Callable[..., nn.Module] = misc_nn_ops.FrozenBatchNorm2d,
+ trainable_layers: int = 2,
+ returned_layers: Optional[List[int]] = None,
+ extra_blocks: Optional[ExtraFPNBlock] = None,
+) -> nn.Module:
+ backbone = mobilenet.__dict__[backbone_name](weights=weights, norm_layer=norm_layer)
+ return _mobilenet_extractor(backbone, fpn, trainable_layers, returned_layers, extra_blocks)
+
+
+def _mobilenet_extractor(
+ backbone: Union[mobilenet.MobileNetV2, mobilenet.MobileNetV3],
+ fpn: bool,
+ trainable_layers: int,
+ returned_layers: Optional[List[int]] = None,
+ extra_blocks: Optional[ExtraFPNBlock] = None,
+ norm_layer: Optional[Callable[..., nn.Module]] = None,
+) -> nn.Module:
+ backbone = backbone.features
+ # Gather the indices of blocks which are strided. These are the locations of C1, ..., Cn-1 blocks.
+ # The first and last blocks are always included because they are the C0 (conv1) and Cn.
+ stage_indices = [0] + [i for i, b in enumerate(backbone) if getattr(b, "_is_cn", False)] + [len(backbone) - 1]
+ num_stages = len(stage_indices)
+
+ # find the index of the layer from which we won't freeze
+ if trainable_layers < 0 or trainable_layers > num_stages:
+ raise ValueError(f"Trainable layers should be in the range [0,{num_stages}], got {trainable_layers} ")
+ freeze_before = len(backbone) if trainable_layers == 0 else stage_indices[num_stages - trainable_layers]
+
+ for b in backbone[:freeze_before]:
+ for parameter in b.parameters():
+ parameter.requires_grad_(False)
+
+ out_channels = 256
+ if fpn:
+ if extra_blocks is None:
+ extra_blocks = LastLevelMaxPool()
+
+ if returned_layers is None:
+ returned_layers = [num_stages - 2, num_stages - 1]
+ if min(returned_layers) < 0 or max(returned_layers) >= num_stages:
+ raise ValueError(f"Each returned layer should be in the range [0,{num_stages - 1}], got {returned_layers} ")
+ return_layers = {f"{stage_indices[k]}": str(v) for v, k in enumerate(returned_layers)}
+
+ in_channels_list = [backbone[stage_indices[i]].out_channels for i in returned_layers]
+ return BackboneWithFPN(
+ backbone, return_layers, in_channels_list, out_channels, extra_blocks=extra_blocks, norm_layer=norm_layer
+ )
+ else:
+ m = nn.Sequential(
+ backbone,
+ # depthwise linear combination of channels to reduce their size
+ nn.Conv2d(backbone[-1].out_channels, out_channels, 1),
+ )
+ m.out_channels = out_channels # type: ignore[assignment]
+ return m
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/fcos.py b/wemm/lib/python3.10/site-packages/torchvision/models/detection/fcos.py
new file mode 100644
index 0000000000000000000000000000000000000000..8c6f84ca5ffd45a2066f0631abbdb508ddaa7454
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/detection/fcos.py
@@ -0,0 +1,771 @@
+import math
+import warnings
+from collections import OrderedDict
+from functools import partial
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import torch
+from torch import nn, Tensor
+
+from ...ops import boxes as box_ops, generalized_box_iou_loss, misc as misc_nn_ops, sigmoid_focal_loss
+from ...ops.feature_pyramid_network import LastLevelP6P7
+from ...transforms._presets import ObjectDetection
+from ...utils import _log_api_usage_once
+from .._api import register_model, Weights, WeightsEnum
+from .._meta import _COCO_CATEGORIES
+from .._utils import _ovewrite_value_param, handle_legacy_interface
+from ..resnet import resnet50, ResNet50_Weights
+from . import _utils as det_utils
+from .anchor_utils import AnchorGenerator
+from .backbone_utils import _resnet_fpn_extractor, _validate_trainable_layers
+from .transform import GeneralizedRCNNTransform
+
+
+__all__ = [
+ "FCOS",
+ "FCOS_ResNet50_FPN_Weights",
+ "fcos_resnet50_fpn",
+]
+
+
+class FCOSHead(nn.Module):
+ """
+ A regression and classification head for use in FCOS.
+
+ Args:
+ in_channels (int): number of channels of the input feature
+ num_anchors (int): number of anchors to be predicted
+ num_classes (int): number of classes to be predicted
+ num_convs (Optional[int]): number of conv layer of head. Default: 4.
+ """
+
+ __annotations__ = {
+ "box_coder": det_utils.BoxLinearCoder,
+ }
+
+ def __init__(self, in_channels: int, num_anchors: int, num_classes: int, num_convs: Optional[int] = 4) -> None:
+ super().__init__()
+ self.box_coder = det_utils.BoxLinearCoder(normalize_by_size=True)
+ self.classification_head = FCOSClassificationHead(in_channels, num_anchors, num_classes, num_convs)
+ self.regression_head = FCOSRegressionHead(in_channels, num_anchors, num_convs)
+
+ def compute_loss(
+ self,
+ targets: List[Dict[str, Tensor]],
+ head_outputs: Dict[str, Tensor],
+ anchors: List[Tensor],
+ matched_idxs: List[Tensor],
+ ) -> Dict[str, Tensor]:
+
+ cls_logits = head_outputs["cls_logits"] # [N, HWA, C]
+ bbox_regression = head_outputs["bbox_regression"] # [N, HWA, 4]
+ bbox_ctrness = head_outputs["bbox_ctrness"] # [N, HWA, 1]
+
+ all_gt_classes_targets = []
+ all_gt_boxes_targets = []
+ for targets_per_image, matched_idxs_per_image in zip(targets, matched_idxs):
+ if len(targets_per_image["labels"]) == 0:
+ gt_classes_targets = targets_per_image["labels"].new_zeros((len(matched_idxs_per_image),))
+ gt_boxes_targets = targets_per_image["boxes"].new_zeros((len(matched_idxs_per_image), 4))
+ else:
+ gt_classes_targets = targets_per_image["labels"][matched_idxs_per_image.clip(min=0)]
+ gt_boxes_targets = targets_per_image["boxes"][matched_idxs_per_image.clip(min=0)]
+ gt_classes_targets[matched_idxs_per_image < 0] = -1 # background
+ all_gt_classes_targets.append(gt_classes_targets)
+ all_gt_boxes_targets.append(gt_boxes_targets)
+
+ # List[Tensor] to Tensor conversion of `all_gt_boxes_target`, `all_gt_classes_targets` and `anchors`
+ all_gt_boxes_targets, all_gt_classes_targets, anchors = (
+ torch.stack(all_gt_boxes_targets),
+ torch.stack(all_gt_classes_targets),
+ torch.stack(anchors),
+ )
+
+ # compute foregroud
+ foregroud_mask = all_gt_classes_targets >= 0
+ num_foreground = foregroud_mask.sum().item()
+
+ # classification loss
+ gt_classes_targets = torch.zeros_like(cls_logits)
+ gt_classes_targets[foregroud_mask, all_gt_classes_targets[foregroud_mask]] = 1.0
+ loss_cls = sigmoid_focal_loss(cls_logits, gt_classes_targets, reduction="sum")
+
+ # amp issue: pred_boxes need to convert float
+ pred_boxes = self.box_coder.decode(bbox_regression, anchors)
+
+ # regression loss: GIoU loss
+ loss_bbox_reg = generalized_box_iou_loss(
+ pred_boxes[foregroud_mask],
+ all_gt_boxes_targets[foregroud_mask],
+ reduction="sum",
+ )
+
+ # ctrness loss
+
+ bbox_reg_targets = self.box_coder.encode(anchors, all_gt_boxes_targets)
+
+ if len(bbox_reg_targets) == 0:
+ gt_ctrness_targets = bbox_reg_targets.new_zeros(bbox_reg_targets.size()[:-1])
+ else:
+ left_right = bbox_reg_targets[:, :, [0, 2]]
+ top_bottom = bbox_reg_targets[:, :, [1, 3]]
+ gt_ctrness_targets = torch.sqrt(
+ (left_right.min(dim=-1)[0] / left_right.max(dim=-1)[0])
+ * (top_bottom.min(dim=-1)[0] / top_bottom.max(dim=-1)[0])
+ )
+ pred_centerness = bbox_ctrness.squeeze(dim=2)
+ loss_bbox_ctrness = nn.functional.binary_cross_entropy_with_logits(
+ pred_centerness[foregroud_mask], gt_ctrness_targets[foregroud_mask], reduction="sum"
+ )
+
+ return {
+ "classification": loss_cls / max(1, num_foreground),
+ "bbox_regression": loss_bbox_reg / max(1, num_foreground),
+ "bbox_ctrness": loss_bbox_ctrness / max(1, num_foreground),
+ }
+
+ def forward(self, x: List[Tensor]) -> Dict[str, Tensor]:
+ cls_logits = self.classification_head(x)
+ bbox_regression, bbox_ctrness = self.regression_head(x)
+ return {
+ "cls_logits": cls_logits,
+ "bbox_regression": bbox_regression,
+ "bbox_ctrness": bbox_ctrness,
+ }
+
+
+class FCOSClassificationHead(nn.Module):
+ """
+ A classification head for use in FCOS.
+
+ Args:
+ in_channels (int): number of channels of the input feature.
+ num_anchors (int): number of anchors to be predicted.
+ num_classes (int): number of classes to be predicted.
+ num_convs (Optional[int]): number of conv layer. Default: 4.
+ prior_probability (Optional[float]): probability of prior. Default: 0.01.
+ norm_layer: Module specifying the normalization layer to use.
+ """
+
+ def __init__(
+ self,
+ in_channels: int,
+ num_anchors: int,
+ num_classes: int,
+ num_convs: int = 4,
+ prior_probability: float = 0.01,
+ norm_layer: Optional[Callable[..., nn.Module]] = None,
+ ) -> None:
+ super().__init__()
+
+ self.num_classes = num_classes
+ self.num_anchors = num_anchors
+
+ if norm_layer is None:
+ norm_layer = partial(nn.GroupNorm, 32)
+
+ conv = []
+ for _ in range(num_convs):
+ conv.append(nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1))
+ conv.append(norm_layer(in_channels))
+ conv.append(nn.ReLU())
+ self.conv = nn.Sequential(*conv)
+
+ for layer in self.conv.children():
+ if isinstance(layer, nn.Conv2d):
+ torch.nn.init.normal_(layer.weight, std=0.01)
+ torch.nn.init.constant_(layer.bias, 0)
+
+ self.cls_logits = nn.Conv2d(in_channels, num_anchors * num_classes, kernel_size=3, stride=1, padding=1)
+ torch.nn.init.normal_(self.cls_logits.weight, std=0.01)
+ torch.nn.init.constant_(self.cls_logits.bias, -math.log((1 - prior_probability) / prior_probability))
+
+ def forward(self, x: List[Tensor]) -> Tensor:
+ all_cls_logits = []
+
+ for features in x:
+ cls_logits = self.conv(features)
+ cls_logits = self.cls_logits(cls_logits)
+
+ # Permute classification output from (N, A * K, H, W) to (N, HWA, K).
+ N, _, H, W = cls_logits.shape
+ cls_logits = cls_logits.view(N, -1, self.num_classes, H, W)
+ cls_logits = cls_logits.permute(0, 3, 4, 1, 2)
+ cls_logits = cls_logits.reshape(N, -1, self.num_classes) # Size=(N, HWA, 4)
+
+ all_cls_logits.append(cls_logits)
+
+ return torch.cat(all_cls_logits, dim=1)
+
+
+class FCOSRegressionHead(nn.Module):
+ """
+ A regression head for use in FCOS, which combines regression branch and center-ness branch.
+ This can obtain better performance.
+
+ Reference: `FCOS: A simple and strong anchor-free object detector `_.
+
+ Args:
+ in_channels (int): number of channels of the input feature
+ num_anchors (int): number of anchors to be predicted
+ num_convs (Optional[int]): number of conv layer. Default: 4.
+ norm_layer: Module specifying the normalization layer to use.
+ """
+
+ def __init__(
+ self,
+ in_channels: int,
+ num_anchors: int,
+ num_convs: int = 4,
+ norm_layer: Optional[Callable[..., nn.Module]] = None,
+ ):
+ super().__init__()
+
+ if norm_layer is None:
+ norm_layer = partial(nn.GroupNorm, 32)
+
+ conv = []
+ for _ in range(num_convs):
+ conv.append(nn.Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1))
+ conv.append(norm_layer(in_channels))
+ conv.append(nn.ReLU())
+ self.conv = nn.Sequential(*conv)
+
+ self.bbox_reg = nn.Conv2d(in_channels, num_anchors * 4, kernel_size=3, stride=1, padding=1)
+ self.bbox_ctrness = nn.Conv2d(in_channels, num_anchors * 1, kernel_size=3, stride=1, padding=1)
+ for layer in [self.bbox_reg, self.bbox_ctrness]:
+ torch.nn.init.normal_(layer.weight, std=0.01)
+ torch.nn.init.zeros_(layer.bias)
+
+ for layer in self.conv.children():
+ if isinstance(layer, nn.Conv2d):
+ torch.nn.init.normal_(layer.weight, std=0.01)
+ torch.nn.init.zeros_(layer.bias)
+
+ def forward(self, x: List[Tensor]) -> Tuple[Tensor, Tensor]:
+ all_bbox_regression = []
+ all_bbox_ctrness = []
+
+ for features in x:
+ bbox_feature = self.conv(features)
+ bbox_regression = nn.functional.relu(self.bbox_reg(bbox_feature))
+ bbox_ctrness = self.bbox_ctrness(bbox_feature)
+
+ # permute bbox regression output from (N, 4 * A, H, W) to (N, HWA, 4).
+ N, _, H, W = bbox_regression.shape
+ bbox_regression = bbox_regression.view(N, -1, 4, H, W)
+ bbox_regression = bbox_regression.permute(0, 3, 4, 1, 2)
+ bbox_regression = bbox_regression.reshape(N, -1, 4) # Size=(N, HWA, 4)
+ all_bbox_regression.append(bbox_regression)
+
+ # permute bbox ctrness output from (N, 1 * A, H, W) to (N, HWA, 1).
+ bbox_ctrness = bbox_ctrness.view(N, -1, 1, H, W)
+ bbox_ctrness = bbox_ctrness.permute(0, 3, 4, 1, 2)
+ bbox_ctrness = bbox_ctrness.reshape(N, -1, 1)
+ all_bbox_ctrness.append(bbox_ctrness)
+
+ return torch.cat(all_bbox_regression, dim=1), torch.cat(all_bbox_ctrness, dim=1)
+
+
+class FCOS(nn.Module):
+ """
+ Implements FCOS.
+
+ The input to the model is expected to be a list of tensors, each of shape [C, H, W], one for each
+ image, and should be in 0-1 range. Different images can have different sizes.
+
+ The behavior of the model changes depending on if it is in training or evaluation mode.
+
+ During training, the model expects both the input tensors and targets (list of dictionary),
+ containing:
+ - boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (Int64Tensor[N]): the class label for each ground-truth box
+
+ The model returns a Dict[Tensor] during training, containing the classification, regression
+ and centerness losses.
+
+ During inference, the model requires only the input tensors, and returns the post-processed
+ predictions as a List[Dict[Tensor]], one for each input image. The fields of the Dict are as
+ follows:
+ - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (Int64Tensor[N]): the predicted labels for each image
+ - scores (Tensor[N]): the scores for each prediction
+
+ Args:
+ backbone (nn.Module): the network used to compute the features for the model.
+ It should contain an out_channels attribute, which indicates the number of output
+ channels that each feature map has (and it should be the same for all feature maps).
+ The backbone should return a single Tensor or an OrderedDict[Tensor].
+ num_classes (int): number of output classes of the model (including the background).
+ min_size (int): minimum size of the image to be rescaled before feeding it to the backbone
+ max_size (int): maximum size of the image to be rescaled before feeding it to the backbone
+ image_mean (Tuple[float, float, float]): mean values used for input normalization.
+ They are generally the mean values of the dataset on which the backbone has been trained
+ on
+ image_std (Tuple[float, float, float]): std values used for input normalization.
+ They are generally the std values of the dataset on which the backbone has been trained on
+ anchor_generator (AnchorGenerator): module that generates the anchors for a set of feature
+ maps. For FCOS, only set one anchor for per position of each level, the width and height equal to
+ the stride of feature map, and set aspect ratio = 1.0, so the center of anchor is equivalent to the point
+ in FCOS paper.
+ head (nn.Module): Module run on top of the feature pyramid.
+ Defaults to a module containing a classification and regression module.
+ center_sampling_radius (int): radius of the "center" of a groundtruth box,
+ within which all anchor points are labeled positive.
+ score_thresh (float): Score threshold used for postprocessing the detections.
+ nms_thresh (float): NMS threshold used for postprocessing the detections.
+ detections_per_img (int): Number of best detections to keep after NMS.
+ topk_candidates (int): Number of best detections to keep before NMS.
+
+ Example:
+
+ >>> import torch
+ >>> import torchvision
+ >>> from torchvision.models.detection import FCOS
+ >>> from torchvision.models.detection.anchor_utils import AnchorGenerator
+ >>> # load a pre-trained model for classification and return
+ >>> # only the features
+ >>> backbone = torchvision.models.mobilenet_v2(weights=MobileNet_V2_Weights.DEFAULT).features
+ >>> # FCOS needs to know the number of
+ >>> # output channels in a backbone. For mobilenet_v2, it's 1280,
+ >>> # so we need to add it here
+ >>> backbone.out_channels = 1280
+ >>>
+ >>> # let's make the network generate 5 x 3 anchors per spatial
+ >>> # location, with 5 different sizes and 3 different aspect
+ >>> # ratios. We have a Tuple[Tuple[int]] because each feature
+ >>> # map could potentially have different sizes and
+ >>> # aspect ratios
+ >>> anchor_generator = AnchorGenerator(
+ >>> sizes=((8,), (16,), (32,), (64,), (128,)),
+ >>> aspect_ratios=((1.0,),)
+ >>> )
+ >>>
+ >>> # put the pieces together inside a FCOS model
+ >>> model = FCOS(
+ >>> backbone,
+ >>> num_classes=80,
+ >>> anchor_generator=anchor_generator,
+ >>> )
+ >>> model.eval()
+ >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
+ >>> predictions = model(x)
+ """
+
+ __annotations__ = {
+ "box_coder": det_utils.BoxLinearCoder,
+ }
+
+ def __init__(
+ self,
+ backbone: nn.Module,
+ num_classes: int,
+ # transform parameters
+ min_size: int = 800,
+ max_size: int = 1333,
+ image_mean: Optional[List[float]] = None,
+ image_std: Optional[List[float]] = None,
+ # Anchor parameters
+ anchor_generator: Optional[AnchorGenerator] = None,
+ head: Optional[nn.Module] = None,
+ center_sampling_radius: float = 1.5,
+ score_thresh: float = 0.2,
+ nms_thresh: float = 0.6,
+ detections_per_img: int = 100,
+ topk_candidates: int = 1000,
+ **kwargs,
+ ):
+ super().__init__()
+ _log_api_usage_once(self)
+
+ if not hasattr(backbone, "out_channels"):
+ raise ValueError(
+ "backbone should contain an attribute out_channels "
+ "specifying the number of output channels (assumed to be the "
+ "same for all the levels)"
+ )
+ self.backbone = backbone
+
+ if not isinstance(anchor_generator, (AnchorGenerator, type(None))):
+ raise TypeError(
+ f"anchor_generator should be of type AnchorGenerator or None, instead got {type(anchor_generator)}"
+ )
+
+ if anchor_generator is None:
+ anchor_sizes = ((8,), (16,), (32,), (64,), (128,)) # equal to strides of multi-level feature map
+ aspect_ratios = ((1.0,),) * len(anchor_sizes) # set only one anchor
+ anchor_generator = AnchorGenerator(anchor_sizes, aspect_ratios)
+ self.anchor_generator = anchor_generator
+ if self.anchor_generator.num_anchors_per_location()[0] != 1:
+ raise ValueError(
+ f"anchor_generator.num_anchors_per_location()[0] should be 1 instead of {anchor_generator.num_anchors_per_location()[0]}"
+ )
+
+ if head is None:
+ head = FCOSHead(backbone.out_channels, anchor_generator.num_anchors_per_location()[0], num_classes)
+ self.head = head
+
+ self.box_coder = det_utils.BoxLinearCoder(normalize_by_size=True)
+
+ if image_mean is None:
+ image_mean = [0.485, 0.456, 0.406]
+ if image_std is None:
+ image_std = [0.229, 0.224, 0.225]
+ self.transform = GeneralizedRCNNTransform(min_size, max_size, image_mean, image_std, **kwargs)
+
+ self.center_sampling_radius = center_sampling_radius
+ self.score_thresh = score_thresh
+ self.nms_thresh = nms_thresh
+ self.detections_per_img = detections_per_img
+ self.topk_candidates = topk_candidates
+
+ # used only on torchscript mode
+ self._has_warned = False
+
+ @torch.jit.unused
+ def eager_outputs(
+ self, losses: Dict[str, Tensor], detections: List[Dict[str, Tensor]]
+ ) -> Tuple[Dict[str, Tensor], List[Dict[str, Tensor]]]:
+ if self.training:
+ return losses
+
+ return detections
+
+ def compute_loss(
+ self,
+ targets: List[Dict[str, Tensor]],
+ head_outputs: Dict[str, Tensor],
+ anchors: List[Tensor],
+ num_anchors_per_level: List[int],
+ ) -> Dict[str, Tensor]:
+ matched_idxs = []
+ for anchors_per_image, targets_per_image in zip(anchors, targets):
+ if targets_per_image["boxes"].numel() == 0:
+ matched_idxs.append(
+ torch.full((anchors_per_image.size(0),), -1, dtype=torch.int64, device=anchors_per_image.device)
+ )
+ continue
+
+ gt_boxes = targets_per_image["boxes"]
+ gt_centers = (gt_boxes[:, :2] + gt_boxes[:, 2:]) / 2 # Nx2
+ anchor_centers = (anchors_per_image[:, :2] + anchors_per_image[:, 2:]) / 2 # N
+ anchor_sizes = anchors_per_image[:, 2] - anchors_per_image[:, 0]
+ # center sampling: anchor point must be close enough to gt center.
+ pairwise_match = (anchor_centers[:, None, :] - gt_centers[None, :, :]).abs_().max(
+ dim=2
+ ).values < self.center_sampling_radius * anchor_sizes[:, None]
+ # compute pairwise distance between N points and M boxes
+ x, y = anchor_centers.unsqueeze(dim=2).unbind(dim=1) # (N, 1)
+ x0, y0, x1, y1 = gt_boxes.unsqueeze(dim=0).unbind(dim=2) # (1, M)
+ pairwise_dist = torch.stack([x - x0, y - y0, x1 - x, y1 - y], dim=2) # (N, M)
+
+ # anchor point must be inside gt
+ pairwise_match &= pairwise_dist.min(dim=2).values > 0
+
+ # each anchor is only responsible for certain scale range.
+ lower_bound = anchor_sizes * 4
+ lower_bound[: num_anchors_per_level[0]] = 0
+ upper_bound = anchor_sizes * 8
+ upper_bound[-num_anchors_per_level[-1] :] = float("inf")
+ pairwise_dist = pairwise_dist.max(dim=2).values
+ pairwise_match &= (pairwise_dist > lower_bound[:, None]) & (pairwise_dist < upper_bound[:, None])
+
+ # match the GT box with minimum area, if there are multiple GT matches
+ gt_areas = (gt_boxes[:, 2] - gt_boxes[:, 0]) * (gt_boxes[:, 3] - gt_boxes[:, 1]) # N
+ pairwise_match = pairwise_match.to(torch.float32) * (1e8 - gt_areas[None, :])
+ min_values, matched_idx = pairwise_match.max(dim=1) # R, per-anchor match
+ matched_idx[min_values < 1e-5] = -1 # unmatched anchors are assigned -1
+
+ matched_idxs.append(matched_idx)
+
+ return self.head.compute_loss(targets, head_outputs, anchors, matched_idxs)
+
+ def postprocess_detections(
+ self, head_outputs: Dict[str, List[Tensor]], anchors: List[List[Tensor]], image_shapes: List[Tuple[int, int]]
+ ) -> List[Dict[str, Tensor]]:
+ class_logits = head_outputs["cls_logits"]
+ box_regression = head_outputs["bbox_regression"]
+ box_ctrness = head_outputs["bbox_ctrness"]
+
+ num_images = len(image_shapes)
+
+ detections: List[Dict[str, Tensor]] = []
+
+ for index in range(num_images):
+ box_regression_per_image = [br[index] for br in box_regression]
+ logits_per_image = [cl[index] for cl in class_logits]
+ box_ctrness_per_image = [bc[index] for bc in box_ctrness]
+ anchors_per_image, image_shape = anchors[index], image_shapes[index]
+
+ image_boxes = []
+ image_scores = []
+ image_labels = []
+
+ for box_regression_per_level, logits_per_level, box_ctrness_per_level, anchors_per_level in zip(
+ box_regression_per_image, logits_per_image, box_ctrness_per_image, anchors_per_image
+ ):
+ num_classes = logits_per_level.shape[-1]
+
+ # remove low scoring boxes
+ scores_per_level = torch.sqrt(
+ torch.sigmoid(logits_per_level) * torch.sigmoid(box_ctrness_per_level)
+ ).flatten()
+ keep_idxs = scores_per_level > self.score_thresh
+ scores_per_level = scores_per_level[keep_idxs]
+ topk_idxs = torch.where(keep_idxs)[0]
+
+ # keep only topk scoring predictions
+ num_topk = det_utils._topk_min(topk_idxs, self.topk_candidates, 0)
+ scores_per_level, idxs = scores_per_level.topk(num_topk)
+ topk_idxs = topk_idxs[idxs]
+
+ anchor_idxs = torch.div(topk_idxs, num_classes, rounding_mode="floor")
+ labels_per_level = topk_idxs % num_classes
+
+ boxes_per_level = self.box_coder.decode(
+ box_regression_per_level[anchor_idxs], anchors_per_level[anchor_idxs]
+ )
+ boxes_per_level = box_ops.clip_boxes_to_image(boxes_per_level, image_shape)
+
+ image_boxes.append(boxes_per_level)
+ image_scores.append(scores_per_level)
+ image_labels.append(labels_per_level)
+
+ image_boxes = torch.cat(image_boxes, dim=0)
+ image_scores = torch.cat(image_scores, dim=0)
+ image_labels = torch.cat(image_labels, dim=0)
+
+ # non-maximum suppression
+ keep = box_ops.batched_nms(image_boxes, image_scores, image_labels, self.nms_thresh)
+ keep = keep[: self.detections_per_img]
+
+ detections.append(
+ {
+ "boxes": image_boxes[keep],
+ "scores": image_scores[keep],
+ "labels": image_labels[keep],
+ }
+ )
+
+ return detections
+
+ def forward(
+ self,
+ images: List[Tensor],
+ targets: Optional[List[Dict[str, Tensor]]] = None,
+ ) -> Tuple[Dict[str, Tensor], List[Dict[str, Tensor]]]:
+ """
+ Args:
+ images (list[Tensor]): images to be processed
+ targets (list[Dict[Tensor]]): ground-truth boxes present in the image (optional)
+
+ Returns:
+ result (list[BoxList] or dict[Tensor]): the output from the model.
+ During training, it returns a dict[Tensor] which contains the losses.
+ During testing, it returns list[BoxList] contains additional fields
+ like `scores`, `labels` and `mask` (for Mask R-CNN models).
+ """
+ if self.training:
+
+ if targets is None:
+ torch._assert(False, "targets should not be none when in training mode")
+ else:
+ for target in targets:
+ boxes = target["boxes"]
+ torch._assert(isinstance(boxes, torch.Tensor), "Expected target boxes to be of type Tensor.")
+ torch._assert(
+ len(boxes.shape) == 2 and boxes.shape[-1] == 4,
+ f"Expected target boxes to be a tensor of shape [N, 4], got {boxes.shape}.",
+ )
+
+ original_image_sizes: List[Tuple[int, int]] = []
+ for img in images:
+ val = img.shape[-2:]
+ torch._assert(
+ len(val) == 2,
+ f"expecting the last two dimensions of the Tensor to be H and W instead got {img.shape[-2:]}",
+ )
+ original_image_sizes.append((val[0], val[1]))
+
+ # transform the input
+ images, targets = self.transform(images, targets)
+
+ # Check for degenerate boxes
+ if targets is not None:
+ for target_idx, target in enumerate(targets):
+ boxes = target["boxes"]
+ degenerate_boxes = boxes[:, 2:] <= boxes[:, :2]
+ if degenerate_boxes.any():
+ # print the first degenerate box
+ bb_idx = torch.where(degenerate_boxes.any(dim=1))[0][0]
+ degen_bb: List[float] = boxes[bb_idx].tolist()
+ torch._assert(
+ False,
+ f"All bounding boxes should have positive height and width. Found invalid box {degen_bb} for target at index {target_idx}.",
+ )
+
+ # get the features from the backbone
+ features = self.backbone(images.tensors)
+ if isinstance(features, torch.Tensor):
+ features = OrderedDict([("0", features)])
+
+ features = list(features.values())
+
+ # compute the fcos heads outputs using the features
+ head_outputs = self.head(features)
+
+ # create the set of anchors
+ anchors = self.anchor_generator(images, features)
+ # recover level sizes
+ num_anchors_per_level = [x.size(2) * x.size(3) for x in features]
+
+ losses = {}
+ detections: List[Dict[str, Tensor]] = []
+ if self.training:
+ if targets is None:
+ torch._assert(False, "targets should not be none when in training mode")
+ else:
+ # compute the losses
+ losses = self.compute_loss(targets, head_outputs, anchors, num_anchors_per_level)
+ else:
+ # split outputs per level
+ split_head_outputs: Dict[str, List[Tensor]] = {}
+ for k in head_outputs:
+ split_head_outputs[k] = list(head_outputs[k].split(num_anchors_per_level, dim=1))
+ split_anchors = [list(a.split(num_anchors_per_level)) for a in anchors]
+
+ # compute the detections
+ detections = self.postprocess_detections(split_head_outputs, split_anchors, images.image_sizes)
+ detections = self.transform.postprocess(detections, images.image_sizes, original_image_sizes)
+
+ if torch.jit.is_scripting():
+ if not self._has_warned:
+ warnings.warn("FCOS always returns a (Losses, Detections) tuple in scripting")
+ self._has_warned = True
+ return losses, detections
+ return self.eager_outputs(losses, detections)
+
+
+class FCOS_ResNet50_FPN_Weights(WeightsEnum):
+ COCO_V1 = Weights(
+ url="https://download.pytorch.org/models/fcos_resnet50_fpn_coco-99b0c9b7.pth",
+ transforms=ObjectDetection,
+ meta={
+ "num_params": 32269600,
+ "categories": _COCO_CATEGORIES,
+ "min_size": (1, 1),
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/detection#fcos-resnet-50-fpn",
+ "_metrics": {
+ "COCO-val2017": {
+ "box_map": 39.2,
+ }
+ },
+ "_ops": 128.207,
+ "_file_size": 123.608,
+ "_docs": """These weights were produced by following a similar training recipe as on the paper.""",
+ },
+ )
+ DEFAULT = COCO_V1
+
+
+@register_model()
+@handle_legacy_interface(
+ weights=("pretrained", FCOS_ResNet50_FPN_Weights.COCO_V1),
+ weights_backbone=("pretrained_backbone", ResNet50_Weights.IMAGENET1K_V1),
+)
+def fcos_resnet50_fpn(
+ *,
+ weights: Optional[FCOS_ResNet50_FPN_Weights] = None,
+ progress: bool = True,
+ num_classes: Optional[int] = None,
+ weights_backbone: Optional[ResNet50_Weights] = ResNet50_Weights.IMAGENET1K_V1,
+ trainable_backbone_layers: Optional[int] = None,
+ **kwargs: Any,
+) -> FCOS:
+ """
+ Constructs a FCOS model with a ResNet-50-FPN backbone.
+
+ .. betastatus:: detection module
+
+ Reference: `FCOS: Fully Convolutional One-Stage Object Detection `_.
+ `FCOS: A simple and strong anchor-free object detector `_.
+
+ The input to the model is expected to be a list of tensors, each of shape ``[C, H, W]``, one for each
+ image, and should be in ``0-1`` range. Different images can have different sizes.
+
+ The behavior of the model changes depending on if it is in training or evaluation mode.
+
+ During training, the model expects both the input tensors and targets (list of dictionary),
+ containing:
+
+ - boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (``Int64Tensor[N]``): the class label for each ground-truth box
+
+ The model returns a ``Dict[Tensor]`` during training, containing the classification and regression
+ losses.
+
+ During inference, the model requires only the input tensors, and returns the post-processed
+ predictions as a ``List[Dict[Tensor]]``, one for each input image. The fields of the ``Dict`` are as
+ follows, where ``N`` is the number of detections:
+
+ - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (``Int64Tensor[N]``): the predicted labels for each detection
+ - scores (``Tensor[N]``): the scores of each detection
+
+ For more details on the output, you may refer to :ref:`instance_seg_output`.
+
+ Example:
+
+ >>> model = torchvision.models.detection.fcos_resnet50_fpn(weights=FCOS_ResNet50_FPN_Weights.DEFAULT)
+ >>> model.eval()
+ >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
+ >>> predictions = model(x)
+
+ Args:
+ weights (:class:`~torchvision.models.detection.FCOS_ResNet50_FPN_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.detection.FCOS_ResNet50_FPN_Weights`
+ below for more details, and possible values. By default, no
+ pre-trained weights are used.
+ progress (bool): If True, displays a progress bar of the download to stderr
+ num_classes (int, optional): number of output classes of the model (including the background)
+ weights_backbone (:class:`~torchvision.models.ResNet50_Weights`, optional): The pretrained weights for
+ the backbone.
+ trainable_backbone_layers (int, optional): number of trainable (not frozen) resnet layers starting
+ from final block. Valid values are between 0 and 5, with 5 meaning all backbone layers are
+ trainable. If ``None`` is passed (the default) this value is set to 3. Default: None
+ **kwargs: parameters passed to the ``torchvision.models.detection.FCOS``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.detection.FCOS_ResNet50_FPN_Weights
+ :members:
+ """
+ weights = FCOS_ResNet50_FPN_Weights.verify(weights)
+ weights_backbone = ResNet50_Weights.verify(weights_backbone)
+
+ if weights is not None:
+ weights_backbone = None
+ num_classes = _ovewrite_value_param("num_classes", num_classes, len(weights.meta["categories"]))
+ elif num_classes is None:
+ num_classes = 91
+
+ is_trained = weights is not None or weights_backbone is not None
+ trainable_backbone_layers = _validate_trainable_layers(is_trained, trainable_backbone_layers, 5, 3)
+ norm_layer = misc_nn_ops.FrozenBatchNorm2d if is_trained else nn.BatchNorm2d
+
+ backbone = resnet50(weights=weights_backbone, progress=progress, norm_layer=norm_layer)
+ backbone = _resnet_fpn_extractor(
+ backbone, trainable_backbone_layers, returned_layers=[2, 3, 4], extra_blocks=LastLevelP6P7(256, 256)
+ )
+ model = FCOS(backbone, num_classes, **kwargs)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/keypoint_rcnn.py b/wemm/lib/python3.10/site-packages/torchvision/models/detection/keypoint_rcnn.py
new file mode 100644
index 0000000000000000000000000000000000000000..5db9911cac06fa05c30908025309e9690d3d50d8
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/detection/keypoint_rcnn.py
@@ -0,0 +1,472 @@
+from typing import Any, Optional
+
+import torch
+from torch import nn
+from torchvision.ops import MultiScaleRoIAlign
+
+from ...ops import misc as misc_nn_ops
+from ...transforms._presets import ObjectDetection
+from .._api import register_model, Weights, WeightsEnum
+from .._meta import _COCO_PERSON_CATEGORIES, _COCO_PERSON_KEYPOINT_NAMES
+from .._utils import _ovewrite_value_param, handle_legacy_interface
+from ..resnet import resnet50, ResNet50_Weights
+from ._utils import overwrite_eps
+from .backbone_utils import _resnet_fpn_extractor, _validate_trainable_layers
+from .faster_rcnn import FasterRCNN
+
+
+__all__ = [
+ "KeypointRCNN",
+ "KeypointRCNN_ResNet50_FPN_Weights",
+ "keypointrcnn_resnet50_fpn",
+]
+
+
+class KeypointRCNN(FasterRCNN):
+ """
+ Implements Keypoint R-CNN.
+
+ The input to the model is expected to be a list of tensors, each of shape [C, H, W], one for each
+ image, and should be in 0-1 range. Different images can have different sizes.
+
+ The behavior of the model changes depending on if it is in training or evaluation mode.
+
+ During training, the model expects both the input tensors and targets (list of dictionary),
+ containing:
+
+ - boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (Int64Tensor[N]): the class label for each ground-truth box
+ - keypoints (FloatTensor[N, K, 3]): the K keypoints location for each of the N instances, in the
+ format [x, y, visibility], where visibility=0 means that the keypoint is not visible.
+
+ The model returns a Dict[Tensor] during training, containing the classification and regression
+ losses for both the RPN and the R-CNN, and the keypoint loss.
+
+ During inference, the model requires only the input tensors, and returns the post-processed
+ predictions as a List[Dict[Tensor]], one for each input image. The fields of the Dict are as
+ follows:
+
+ - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (Int64Tensor[N]): the predicted labels for each image
+ - scores (Tensor[N]): the scores or each prediction
+ - keypoints (FloatTensor[N, K, 3]): the locations of the predicted keypoints, in [x, y, v] format.
+
+ Args:
+ backbone (nn.Module): the network used to compute the features for the model.
+ It should contain an out_channels attribute, which indicates the number of output
+ channels that each feature map has (and it should be the same for all feature maps).
+ The backbone should return a single Tensor or and OrderedDict[Tensor].
+ num_classes (int): number of output classes of the model (including the background).
+ If box_predictor is specified, num_classes should be None.
+ min_size (int): minimum size of the image to be rescaled before feeding it to the backbone
+ max_size (int): maximum size of the image to be rescaled before feeding it to the backbone
+ image_mean (Tuple[float, float, float]): mean values used for input normalization.
+ They are generally the mean values of the dataset on which the backbone has been trained
+ on
+ image_std (Tuple[float, float, float]): std values used for input normalization.
+ They are generally the std values of the dataset on which the backbone has been trained on
+ rpn_anchor_generator (AnchorGenerator): module that generates the anchors for a set of feature
+ maps.
+ rpn_head (nn.Module): module that computes the objectness and regression deltas from the RPN
+ rpn_pre_nms_top_n_train (int): number of proposals to keep before applying NMS during training
+ rpn_pre_nms_top_n_test (int): number of proposals to keep before applying NMS during testing
+ rpn_post_nms_top_n_train (int): number of proposals to keep after applying NMS during training
+ rpn_post_nms_top_n_test (int): number of proposals to keep after applying NMS during testing
+ rpn_nms_thresh (float): NMS threshold used for postprocessing the RPN proposals
+ rpn_fg_iou_thresh (float): minimum IoU between the anchor and the GT box so that they can be
+ considered as positive during training of the RPN.
+ rpn_bg_iou_thresh (float): maximum IoU between the anchor and the GT box so that they can be
+ considered as negative during training of the RPN.
+ rpn_batch_size_per_image (int): number of anchors that are sampled during training of the RPN
+ for computing the loss
+ rpn_positive_fraction (float): proportion of positive anchors in a mini-batch during training
+ of the RPN
+ rpn_score_thresh (float): during inference, only return proposals with a classification score
+ greater than rpn_score_thresh
+ box_roi_pool (MultiScaleRoIAlign): the module which crops and resizes the feature maps in
+ the locations indicated by the bounding boxes
+ box_head (nn.Module): module that takes the cropped feature maps as input
+ box_predictor (nn.Module): module that takes the output of box_head and returns the
+ classification logits and box regression deltas.
+ box_score_thresh (float): during inference, only return proposals with a classification score
+ greater than box_score_thresh
+ box_nms_thresh (float): NMS threshold for the prediction head. Used during inference
+ box_detections_per_img (int): maximum number of detections per image, for all classes.
+ box_fg_iou_thresh (float): minimum IoU between the proposals and the GT box so that they can be
+ considered as positive during training of the classification head
+ box_bg_iou_thresh (float): maximum IoU between the proposals and the GT box so that they can be
+ considered as negative during training of the classification head
+ box_batch_size_per_image (int): number of proposals that are sampled during training of the
+ classification head
+ box_positive_fraction (float): proportion of positive proposals in a mini-batch during training
+ of the classification head
+ bbox_reg_weights (Tuple[float, float, float, float]): weights for the encoding/decoding of the
+ bounding boxes
+ keypoint_roi_pool (MultiScaleRoIAlign): the module which crops and resizes the feature maps in
+ the locations indicated by the bounding boxes, which will be used for the keypoint head.
+ keypoint_head (nn.Module): module that takes the cropped feature maps as input
+ keypoint_predictor (nn.Module): module that takes the output of the keypoint_head and returns the
+ heatmap logits
+
+ Example::
+
+ >>> import torch
+ >>> import torchvision
+ >>> from torchvision.models.detection import KeypointRCNN
+ >>> from torchvision.models.detection.anchor_utils import AnchorGenerator
+ >>>
+ >>> # load a pre-trained model for classification and return
+ >>> # only the features
+ >>> backbone = torchvision.models.mobilenet_v2(weights=MobileNet_V2_Weights.DEFAULT).features
+ >>> # KeypointRCNN needs to know the number of
+ >>> # output channels in a backbone. For mobilenet_v2, it's 1280,
+ >>> # so we need to add it here
+ >>> backbone.out_channels = 1280
+ >>>
+ >>> # let's make the RPN generate 5 x 3 anchors per spatial
+ >>> # location, with 5 different sizes and 3 different aspect
+ >>> # ratios. We have a Tuple[Tuple[int]] because each feature
+ >>> # map could potentially have different sizes and
+ >>> # aspect ratios
+ >>> anchor_generator = AnchorGenerator(sizes=((32, 64, 128, 256, 512),),
+ >>> aspect_ratios=((0.5, 1.0, 2.0),))
+ >>>
+ >>> # let's define what are the feature maps that we will
+ >>> # use to perform the region of interest cropping, as well as
+ >>> # the size of the crop after rescaling.
+ >>> # if your backbone returns a Tensor, featmap_names is expected to
+ >>> # be ['0']. More generally, the backbone should return an
+ >>> # OrderedDict[Tensor], and in featmap_names you can choose which
+ >>> # feature maps to use.
+ >>> roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=['0'],
+ >>> output_size=7,
+ >>> sampling_ratio=2)
+ >>>
+ >>> keypoint_roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=['0'],
+ >>> output_size=14,
+ >>> sampling_ratio=2)
+ >>> # put the pieces together inside a KeypointRCNN model
+ >>> model = KeypointRCNN(backbone,
+ >>> num_classes=2,
+ >>> rpn_anchor_generator=anchor_generator,
+ >>> box_roi_pool=roi_pooler,
+ >>> keypoint_roi_pool=keypoint_roi_pooler)
+ >>> model.eval()
+ >>> model.eval()
+ >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
+ >>> predictions = model(x)
+ """
+
+ def __init__(
+ self,
+ backbone,
+ num_classes=None,
+ # transform parameters
+ min_size=None,
+ max_size=1333,
+ image_mean=None,
+ image_std=None,
+ # RPN parameters
+ rpn_anchor_generator=None,
+ rpn_head=None,
+ rpn_pre_nms_top_n_train=2000,
+ rpn_pre_nms_top_n_test=1000,
+ rpn_post_nms_top_n_train=2000,
+ rpn_post_nms_top_n_test=1000,
+ rpn_nms_thresh=0.7,
+ rpn_fg_iou_thresh=0.7,
+ rpn_bg_iou_thresh=0.3,
+ rpn_batch_size_per_image=256,
+ rpn_positive_fraction=0.5,
+ rpn_score_thresh=0.0,
+ # Box parameters
+ box_roi_pool=None,
+ box_head=None,
+ box_predictor=None,
+ box_score_thresh=0.05,
+ box_nms_thresh=0.5,
+ box_detections_per_img=100,
+ box_fg_iou_thresh=0.5,
+ box_bg_iou_thresh=0.5,
+ box_batch_size_per_image=512,
+ box_positive_fraction=0.25,
+ bbox_reg_weights=None,
+ # keypoint parameters
+ keypoint_roi_pool=None,
+ keypoint_head=None,
+ keypoint_predictor=None,
+ num_keypoints=None,
+ **kwargs,
+ ):
+
+ if not isinstance(keypoint_roi_pool, (MultiScaleRoIAlign, type(None))):
+ raise TypeError(
+ "keypoint_roi_pool should be of type MultiScaleRoIAlign or None instead of {type(keypoint_roi_pool)}"
+ )
+ if min_size is None:
+ min_size = (640, 672, 704, 736, 768, 800)
+
+ if num_keypoints is not None:
+ if keypoint_predictor is not None:
+ raise ValueError("num_keypoints should be None when keypoint_predictor is specified")
+ else:
+ num_keypoints = 17
+
+ out_channels = backbone.out_channels
+
+ if keypoint_roi_pool is None:
+ keypoint_roi_pool = MultiScaleRoIAlign(featmap_names=["0", "1", "2", "3"], output_size=14, sampling_ratio=2)
+
+ if keypoint_head is None:
+ keypoint_layers = tuple(512 for _ in range(8))
+ keypoint_head = KeypointRCNNHeads(out_channels, keypoint_layers)
+
+ if keypoint_predictor is None:
+ keypoint_dim_reduced = 512 # == keypoint_layers[-1]
+ keypoint_predictor = KeypointRCNNPredictor(keypoint_dim_reduced, num_keypoints)
+
+ super().__init__(
+ backbone,
+ num_classes,
+ # transform parameters
+ min_size,
+ max_size,
+ image_mean,
+ image_std,
+ # RPN-specific parameters
+ rpn_anchor_generator,
+ rpn_head,
+ rpn_pre_nms_top_n_train,
+ rpn_pre_nms_top_n_test,
+ rpn_post_nms_top_n_train,
+ rpn_post_nms_top_n_test,
+ rpn_nms_thresh,
+ rpn_fg_iou_thresh,
+ rpn_bg_iou_thresh,
+ rpn_batch_size_per_image,
+ rpn_positive_fraction,
+ rpn_score_thresh,
+ # Box parameters
+ box_roi_pool,
+ box_head,
+ box_predictor,
+ box_score_thresh,
+ box_nms_thresh,
+ box_detections_per_img,
+ box_fg_iou_thresh,
+ box_bg_iou_thresh,
+ box_batch_size_per_image,
+ box_positive_fraction,
+ bbox_reg_weights,
+ **kwargs,
+ )
+
+ self.roi_heads.keypoint_roi_pool = keypoint_roi_pool
+ self.roi_heads.keypoint_head = keypoint_head
+ self.roi_heads.keypoint_predictor = keypoint_predictor
+
+
+class KeypointRCNNHeads(nn.Sequential):
+ def __init__(self, in_channels, layers):
+ d = []
+ next_feature = in_channels
+ for out_channels in layers:
+ d.append(nn.Conv2d(next_feature, out_channels, 3, stride=1, padding=1))
+ d.append(nn.ReLU(inplace=True))
+ next_feature = out_channels
+ super().__init__(*d)
+ for m in self.children():
+ if isinstance(m, nn.Conv2d):
+ nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+ nn.init.constant_(m.bias, 0)
+
+
+class KeypointRCNNPredictor(nn.Module):
+ def __init__(self, in_channels, num_keypoints):
+ super().__init__()
+ input_features = in_channels
+ deconv_kernel = 4
+ self.kps_score_lowres = nn.ConvTranspose2d(
+ input_features,
+ num_keypoints,
+ deconv_kernel,
+ stride=2,
+ padding=deconv_kernel // 2 - 1,
+ )
+ nn.init.kaiming_normal_(self.kps_score_lowres.weight, mode="fan_out", nonlinearity="relu")
+ nn.init.constant_(self.kps_score_lowres.bias, 0)
+ self.up_scale = 2
+ self.out_channels = num_keypoints
+
+ def forward(self, x):
+ x = self.kps_score_lowres(x)
+ return torch.nn.functional.interpolate(
+ x, scale_factor=float(self.up_scale), mode="bilinear", align_corners=False, recompute_scale_factor=False
+ )
+
+
+_COMMON_META = {
+ "categories": _COCO_PERSON_CATEGORIES,
+ "keypoint_names": _COCO_PERSON_KEYPOINT_NAMES,
+ "min_size": (1, 1),
+}
+
+
+class KeypointRCNN_ResNet50_FPN_Weights(WeightsEnum):
+ COCO_LEGACY = Weights(
+ url="https://download.pytorch.org/models/keypointrcnn_resnet50_fpn_coco-9f466800.pth",
+ transforms=ObjectDetection,
+ meta={
+ **_COMMON_META,
+ "num_params": 59137258,
+ "recipe": "https://github.com/pytorch/vision/issues/1606",
+ "_metrics": {
+ "COCO-val2017": {
+ "box_map": 50.6,
+ "kp_map": 61.1,
+ }
+ },
+ "_ops": 133.924,
+ "_file_size": 226.054,
+ "_docs": """
+ These weights were produced by following a similar training recipe as on the paper but use a checkpoint
+ from an early epoch.
+ """,
+ },
+ )
+ COCO_V1 = Weights(
+ url="https://download.pytorch.org/models/keypointrcnn_resnet50_fpn_coco-fc266e95.pth",
+ transforms=ObjectDetection,
+ meta={
+ **_COMMON_META,
+ "num_params": 59137258,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/detection#keypoint-r-cnn",
+ "_metrics": {
+ "COCO-val2017": {
+ "box_map": 54.6,
+ "kp_map": 65.0,
+ }
+ },
+ "_ops": 137.42,
+ "_file_size": 226.054,
+ "_docs": """These weights were produced by following a similar training recipe as on the paper.""",
+ },
+ )
+ DEFAULT = COCO_V1
+
+
+@register_model()
+@handle_legacy_interface(
+ weights=(
+ "pretrained",
+ lambda kwargs: KeypointRCNN_ResNet50_FPN_Weights.COCO_LEGACY
+ if kwargs["pretrained"] == "legacy"
+ else KeypointRCNN_ResNet50_FPN_Weights.COCO_V1,
+ ),
+ weights_backbone=("pretrained_backbone", ResNet50_Weights.IMAGENET1K_V1),
+)
+def keypointrcnn_resnet50_fpn(
+ *,
+ weights: Optional[KeypointRCNN_ResNet50_FPN_Weights] = None,
+ progress: bool = True,
+ num_classes: Optional[int] = None,
+ num_keypoints: Optional[int] = None,
+ weights_backbone: Optional[ResNet50_Weights] = ResNet50_Weights.IMAGENET1K_V1,
+ trainable_backbone_layers: Optional[int] = None,
+ **kwargs: Any,
+) -> KeypointRCNN:
+ """
+ Constructs a Keypoint R-CNN model with a ResNet-50-FPN backbone.
+
+ .. betastatus:: detection module
+
+ Reference: `Mask R-CNN `__.
+
+ The input to the model is expected to be a list of tensors, each of shape ``[C, H, W]``, one for each
+ image, and should be in ``0-1`` range. Different images can have different sizes.
+
+ The behavior of the model changes depending on if it is in training or evaluation mode.
+
+ During training, the model expects both the input tensors and targets (list of dictionary),
+ containing:
+
+ - boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (``Int64Tensor[N]``): the class label for each ground-truth box
+ - keypoints (``FloatTensor[N, K, 3]``): the ``K`` keypoints location for each of the ``N`` instances, in the
+ format ``[x, y, visibility]``, where ``visibility=0`` means that the keypoint is not visible.
+
+ The model returns a ``Dict[Tensor]`` during training, containing the classification and regression
+ losses for both the RPN and the R-CNN, and the keypoint loss.
+
+ During inference, the model requires only the input tensors, and returns the post-processed
+ predictions as a ``List[Dict[Tensor]]``, one for each input image. The fields of the ``Dict`` are as
+ follows, where ``N`` is the number of detected instances:
+
+ - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (``Int64Tensor[N]``): the predicted labels for each instance
+ - scores (``Tensor[N]``): the scores or each instance
+ - keypoints (``FloatTensor[N, K, 3]``): the locations of the predicted keypoints, in ``[x, y, v]`` format.
+
+ For more details on the output, you may refer to :ref:`instance_seg_output`.
+
+ Keypoint R-CNN is exportable to ONNX for a fixed batch size with inputs images of fixed size.
+
+ Example::
+
+ >>> model = torchvision.models.detection.keypointrcnn_resnet50_fpn(weights=KeypointRCNN_ResNet50_FPN_Weights.DEFAULT)
+ >>> model.eval()
+ >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
+ >>> predictions = model(x)
+ >>>
+ >>> # optionally, if you want to export the model to ONNX:
+ >>> torch.onnx.export(model, x, "keypoint_rcnn.onnx", opset_version = 11)
+
+ Args:
+ weights (:class:`~torchvision.models.detection.KeypointRCNN_ResNet50_FPN_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.detection.KeypointRCNN_ResNet50_FPN_Weights`
+ below for more details, and possible values. By default, no
+ pre-trained weights are used.
+ progress (bool): If True, displays a progress bar of the download to stderr
+ num_classes (int, optional): number of output classes of the model (including the background)
+ num_keypoints (int, optional): number of keypoints
+ weights_backbone (:class:`~torchvision.models.ResNet50_Weights`, optional): The
+ pretrained weights for the backbone.
+ trainable_backbone_layers (int, optional): number of trainable (not frozen) layers starting from final block.
+ Valid values are between 0 and 5, with 5 meaning all backbone layers are trainable. If ``None`` is
+ passed (the default) this value is set to 3.
+
+ .. autoclass:: torchvision.models.detection.KeypointRCNN_ResNet50_FPN_Weights
+ :members:
+ """
+ weights = KeypointRCNN_ResNet50_FPN_Weights.verify(weights)
+ weights_backbone = ResNet50_Weights.verify(weights_backbone)
+
+ if weights is not None:
+ weights_backbone = None
+ num_classes = _ovewrite_value_param("num_classes", num_classes, len(weights.meta["categories"]))
+ num_keypoints = _ovewrite_value_param("num_keypoints", num_keypoints, len(weights.meta["keypoint_names"]))
+ else:
+ if num_classes is None:
+ num_classes = 2
+ if num_keypoints is None:
+ num_keypoints = 17
+
+ is_trained = weights is not None or weights_backbone is not None
+ trainable_backbone_layers = _validate_trainable_layers(is_trained, trainable_backbone_layers, 5, 3)
+ norm_layer = misc_nn_ops.FrozenBatchNorm2d if is_trained else nn.BatchNorm2d
+
+ backbone = resnet50(weights=weights_backbone, progress=progress, norm_layer=norm_layer)
+ backbone = _resnet_fpn_extractor(backbone, trainable_backbone_layers)
+ model = KeypointRCNN(backbone, num_classes, num_keypoints=num_keypoints, **kwargs)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+ if weights == KeypointRCNN_ResNet50_FPN_Weights.COCO_V1:
+ overwrite_eps(model, 0.0)
+
+ return model
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/mask_rcnn.py b/wemm/lib/python3.10/site-packages/torchvision/models/detection/mask_rcnn.py
new file mode 100644
index 0000000000000000000000000000000000000000..b2f2cbfe2e39685aa0256bb9ccfeeffabbd78880
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/detection/mask_rcnn.py
@@ -0,0 +1,587 @@
+from collections import OrderedDict
+from typing import Any, Callable, Optional
+
+from torch import nn
+from torchvision.ops import MultiScaleRoIAlign
+
+from ...ops import misc as misc_nn_ops
+from ...transforms._presets import ObjectDetection
+from .._api import register_model, Weights, WeightsEnum
+from .._meta import _COCO_CATEGORIES
+from .._utils import _ovewrite_value_param, handle_legacy_interface
+from ..resnet import resnet50, ResNet50_Weights
+from ._utils import overwrite_eps
+from .backbone_utils import _resnet_fpn_extractor, _validate_trainable_layers
+from .faster_rcnn import _default_anchorgen, FasterRCNN, FastRCNNConvFCHead, RPNHead
+
+
+__all__ = [
+ "MaskRCNN",
+ "MaskRCNN_ResNet50_FPN_Weights",
+ "MaskRCNN_ResNet50_FPN_V2_Weights",
+ "maskrcnn_resnet50_fpn",
+ "maskrcnn_resnet50_fpn_v2",
+]
+
+
+class MaskRCNN(FasterRCNN):
+ """
+ Implements Mask R-CNN.
+
+ The input to the model is expected to be a list of tensors, each of shape [C, H, W], one for each
+ image, and should be in 0-1 range. Different images can have different sizes.
+
+ The behavior of the model changes depending on if it is in training or evaluation mode.
+
+ During training, the model expects both the input tensors and targets (list of dictionary),
+ containing:
+ - boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (Int64Tensor[N]): the class label for each ground-truth box
+ - masks (UInt8Tensor[N, H, W]): the segmentation binary masks for each instance
+
+ The model returns a Dict[Tensor] during training, containing the classification and regression
+ losses for both the RPN and the R-CNN, and the mask loss.
+
+ During inference, the model requires only the input tensors, and returns the post-processed
+ predictions as a List[Dict[Tensor]], one for each input image. The fields of the Dict are as
+ follows:
+ - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (Int64Tensor[N]): the predicted labels for each image
+ - scores (Tensor[N]): the scores or each prediction
+ - masks (UInt8Tensor[N, 1, H, W]): the predicted masks for each instance, in 0-1 range. In order to
+ obtain the final segmentation masks, the soft masks can be thresholded, generally
+ with a value of 0.5 (mask >= 0.5)
+
+ Args:
+ backbone (nn.Module): the network used to compute the features for the model.
+ It should contain an out_channels attribute, which indicates the number of output
+ channels that each feature map has (and it should be the same for all feature maps).
+ The backbone should return a single Tensor or and OrderedDict[Tensor].
+ num_classes (int): number of output classes of the model (including the background).
+ If box_predictor is specified, num_classes should be None.
+ min_size (int): minimum size of the image to be rescaled before feeding it to the backbone
+ max_size (int): maximum size of the image to be rescaled before feeding it to the backbone
+ image_mean (Tuple[float, float, float]): mean values used for input normalization.
+ They are generally the mean values of the dataset on which the backbone has been trained
+ on
+ image_std (Tuple[float, float, float]): std values used for input normalization.
+ They are generally the std values of the dataset on which the backbone has been trained on
+ rpn_anchor_generator (AnchorGenerator): module that generates the anchors for a set of feature
+ maps.
+ rpn_head (nn.Module): module that computes the objectness and regression deltas from the RPN
+ rpn_pre_nms_top_n_train (int): number of proposals to keep before applying NMS during training
+ rpn_pre_nms_top_n_test (int): number of proposals to keep before applying NMS during testing
+ rpn_post_nms_top_n_train (int): number of proposals to keep after applying NMS during training
+ rpn_post_nms_top_n_test (int): number of proposals to keep after applying NMS during testing
+ rpn_nms_thresh (float): NMS threshold used for postprocessing the RPN proposals
+ rpn_fg_iou_thresh (float): minimum IoU between the anchor and the GT box so that they can be
+ considered as positive during training of the RPN.
+ rpn_bg_iou_thresh (float): maximum IoU between the anchor and the GT box so that they can be
+ considered as negative during training of the RPN.
+ rpn_batch_size_per_image (int): number of anchors that are sampled during training of the RPN
+ for computing the loss
+ rpn_positive_fraction (float): proportion of positive anchors in a mini-batch during training
+ of the RPN
+ rpn_score_thresh (float): during inference, only return proposals with a classification score
+ greater than rpn_score_thresh
+ box_roi_pool (MultiScaleRoIAlign): the module which crops and resizes the feature maps in
+ the locations indicated by the bounding boxes
+ box_head (nn.Module): module that takes the cropped feature maps as input
+ box_predictor (nn.Module): module that takes the output of box_head and returns the
+ classification logits and box regression deltas.
+ box_score_thresh (float): during inference, only return proposals with a classification score
+ greater than box_score_thresh
+ box_nms_thresh (float): NMS threshold for the prediction head. Used during inference
+ box_detections_per_img (int): maximum number of detections per image, for all classes.
+ box_fg_iou_thresh (float): minimum IoU between the proposals and the GT box so that they can be
+ considered as positive during training of the classification head
+ box_bg_iou_thresh (float): maximum IoU between the proposals and the GT box so that they can be
+ considered as negative during training of the classification head
+ box_batch_size_per_image (int): number of proposals that are sampled during training of the
+ classification head
+ box_positive_fraction (float): proportion of positive proposals in a mini-batch during training
+ of the classification head
+ bbox_reg_weights (Tuple[float, float, float, float]): weights for the encoding/decoding of the
+ bounding boxes
+ mask_roi_pool (MultiScaleRoIAlign): the module which crops and resizes the feature maps in
+ the locations indicated by the bounding boxes, which will be used for the mask head.
+ mask_head (nn.Module): module that takes the cropped feature maps as input
+ mask_predictor (nn.Module): module that takes the output of the mask_head and returns the
+ segmentation mask logits
+
+ Example::
+
+ >>> import torch
+ >>> import torchvision
+ >>> from torchvision.models.detection import MaskRCNN
+ >>> from torchvision.models.detection.anchor_utils import AnchorGenerator
+ >>>
+ >>> # load a pre-trained model for classification and return
+ >>> # only the features
+ >>> backbone = torchvision.models.mobilenet_v2(weights=MobileNet_V2_Weights.DEFAULT).features
+ >>> # MaskRCNN needs to know the number of
+ >>> # output channels in a backbone. For mobilenet_v2, it's 1280
+ >>> # so we need to add it here,
+ >>> backbone.out_channels = 1280
+ >>>
+ >>> # let's make the RPN generate 5 x 3 anchors per spatial
+ >>> # location, with 5 different sizes and 3 different aspect
+ >>> # ratios. We have a Tuple[Tuple[int]] because each feature
+ >>> # map could potentially have different sizes and
+ >>> # aspect ratios
+ >>> anchor_generator = AnchorGenerator(sizes=((32, 64, 128, 256, 512),),
+ >>> aspect_ratios=((0.5, 1.0, 2.0),))
+ >>>
+ >>> # let's define what are the feature maps that we will
+ >>> # use to perform the region of interest cropping, as well as
+ >>> # the size of the crop after rescaling.
+ >>> # if your backbone returns a Tensor, featmap_names is expected to
+ >>> # be ['0']. More generally, the backbone should return an
+ >>> # OrderedDict[Tensor], and in featmap_names you can choose which
+ >>> # feature maps to use.
+ >>> roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=['0'],
+ >>> output_size=7,
+ >>> sampling_ratio=2)
+ >>>
+ >>> mask_roi_pooler = torchvision.ops.MultiScaleRoIAlign(featmap_names=['0'],
+ >>> output_size=14,
+ >>> sampling_ratio=2)
+ >>> # put the pieces together inside a MaskRCNN model
+ >>> model = MaskRCNN(backbone,
+ >>> num_classes=2,
+ >>> rpn_anchor_generator=anchor_generator,
+ >>> box_roi_pool=roi_pooler,
+ >>> mask_roi_pool=mask_roi_pooler)
+ >>> model.eval()
+ >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
+ >>> predictions = model(x)
+ """
+
+ def __init__(
+ self,
+ backbone,
+ num_classes=None,
+ # transform parameters
+ min_size=800,
+ max_size=1333,
+ image_mean=None,
+ image_std=None,
+ # RPN parameters
+ rpn_anchor_generator=None,
+ rpn_head=None,
+ rpn_pre_nms_top_n_train=2000,
+ rpn_pre_nms_top_n_test=1000,
+ rpn_post_nms_top_n_train=2000,
+ rpn_post_nms_top_n_test=1000,
+ rpn_nms_thresh=0.7,
+ rpn_fg_iou_thresh=0.7,
+ rpn_bg_iou_thresh=0.3,
+ rpn_batch_size_per_image=256,
+ rpn_positive_fraction=0.5,
+ rpn_score_thresh=0.0,
+ # Box parameters
+ box_roi_pool=None,
+ box_head=None,
+ box_predictor=None,
+ box_score_thresh=0.05,
+ box_nms_thresh=0.5,
+ box_detections_per_img=100,
+ box_fg_iou_thresh=0.5,
+ box_bg_iou_thresh=0.5,
+ box_batch_size_per_image=512,
+ box_positive_fraction=0.25,
+ bbox_reg_weights=None,
+ # Mask parameters
+ mask_roi_pool=None,
+ mask_head=None,
+ mask_predictor=None,
+ **kwargs,
+ ):
+
+ if not isinstance(mask_roi_pool, (MultiScaleRoIAlign, type(None))):
+ raise TypeError(
+ f"mask_roi_pool should be of type MultiScaleRoIAlign or None instead of {type(mask_roi_pool)}"
+ )
+
+ if num_classes is not None:
+ if mask_predictor is not None:
+ raise ValueError("num_classes should be None when mask_predictor is specified")
+
+ out_channels = backbone.out_channels
+
+ if mask_roi_pool is None:
+ mask_roi_pool = MultiScaleRoIAlign(featmap_names=["0", "1", "2", "3"], output_size=14, sampling_ratio=2)
+
+ if mask_head is None:
+ mask_layers = (256, 256, 256, 256)
+ mask_dilation = 1
+ mask_head = MaskRCNNHeads(out_channels, mask_layers, mask_dilation)
+
+ if mask_predictor is None:
+ mask_predictor_in_channels = 256 # == mask_layers[-1]
+ mask_dim_reduced = 256
+ mask_predictor = MaskRCNNPredictor(mask_predictor_in_channels, mask_dim_reduced, num_classes)
+
+ super().__init__(
+ backbone,
+ num_classes,
+ # transform parameters
+ min_size,
+ max_size,
+ image_mean,
+ image_std,
+ # RPN-specific parameters
+ rpn_anchor_generator,
+ rpn_head,
+ rpn_pre_nms_top_n_train,
+ rpn_pre_nms_top_n_test,
+ rpn_post_nms_top_n_train,
+ rpn_post_nms_top_n_test,
+ rpn_nms_thresh,
+ rpn_fg_iou_thresh,
+ rpn_bg_iou_thresh,
+ rpn_batch_size_per_image,
+ rpn_positive_fraction,
+ rpn_score_thresh,
+ # Box parameters
+ box_roi_pool,
+ box_head,
+ box_predictor,
+ box_score_thresh,
+ box_nms_thresh,
+ box_detections_per_img,
+ box_fg_iou_thresh,
+ box_bg_iou_thresh,
+ box_batch_size_per_image,
+ box_positive_fraction,
+ bbox_reg_weights,
+ **kwargs,
+ )
+
+ self.roi_heads.mask_roi_pool = mask_roi_pool
+ self.roi_heads.mask_head = mask_head
+ self.roi_heads.mask_predictor = mask_predictor
+
+
+class MaskRCNNHeads(nn.Sequential):
+ _version = 2
+
+ def __init__(self, in_channels, layers, dilation, norm_layer: Optional[Callable[..., nn.Module]] = None):
+ """
+ Args:
+ in_channels (int): number of input channels
+ layers (list): feature dimensions of each FCN layer
+ dilation (int): dilation rate of kernel
+ norm_layer (callable, optional): Module specifying the normalization layer to use. Default: None
+ """
+ blocks = []
+ next_feature = in_channels
+ for layer_features in layers:
+ blocks.append(
+ misc_nn_ops.Conv2dNormActivation(
+ next_feature,
+ layer_features,
+ kernel_size=3,
+ stride=1,
+ padding=dilation,
+ dilation=dilation,
+ norm_layer=norm_layer,
+ )
+ )
+ next_feature = layer_features
+
+ super().__init__(*blocks)
+ for layer in self.modules():
+ if isinstance(layer, nn.Conv2d):
+ nn.init.kaiming_normal_(layer.weight, mode="fan_out", nonlinearity="relu")
+ if layer.bias is not None:
+ nn.init.zeros_(layer.bias)
+
+ def _load_from_state_dict(
+ self,
+ state_dict,
+ prefix,
+ local_metadata,
+ strict,
+ missing_keys,
+ unexpected_keys,
+ error_msgs,
+ ):
+ version = local_metadata.get("version", None)
+
+ if version is None or version < 2:
+ num_blocks = len(self)
+ for i in range(num_blocks):
+ for type in ["weight", "bias"]:
+ old_key = f"{prefix}mask_fcn{i+1}.{type}"
+ new_key = f"{prefix}{i}.0.{type}"
+ if old_key in state_dict:
+ state_dict[new_key] = state_dict.pop(old_key)
+
+ super()._load_from_state_dict(
+ state_dict,
+ prefix,
+ local_metadata,
+ strict,
+ missing_keys,
+ unexpected_keys,
+ error_msgs,
+ )
+
+
+class MaskRCNNPredictor(nn.Sequential):
+ def __init__(self, in_channels, dim_reduced, num_classes):
+ super().__init__(
+ OrderedDict(
+ [
+ ("conv5_mask", nn.ConvTranspose2d(in_channels, dim_reduced, 2, 2, 0)),
+ ("relu", nn.ReLU(inplace=True)),
+ ("mask_fcn_logits", nn.Conv2d(dim_reduced, num_classes, 1, 1, 0)),
+ ]
+ )
+ )
+
+ for name, param in self.named_parameters():
+ if "weight" in name:
+ nn.init.kaiming_normal_(param, mode="fan_out", nonlinearity="relu")
+ # elif "bias" in name:
+ # nn.init.constant_(param, 0)
+
+
+_COMMON_META = {
+ "categories": _COCO_CATEGORIES,
+ "min_size": (1, 1),
+}
+
+
+class MaskRCNN_ResNet50_FPN_Weights(WeightsEnum):
+ COCO_V1 = Weights(
+ url="https://download.pytorch.org/models/maskrcnn_resnet50_fpn_coco-bf2d0c1e.pth",
+ transforms=ObjectDetection,
+ meta={
+ **_COMMON_META,
+ "num_params": 44401393,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/detection#mask-r-cnn",
+ "_metrics": {
+ "COCO-val2017": {
+ "box_map": 37.9,
+ "mask_map": 34.6,
+ }
+ },
+ "_ops": 134.38,
+ "_file_size": 169.84,
+ "_docs": """These weights were produced by following a similar training recipe as on the paper.""",
+ },
+ )
+ DEFAULT = COCO_V1
+
+
+class MaskRCNN_ResNet50_FPN_V2_Weights(WeightsEnum):
+ COCO_V1 = Weights(
+ url="https://download.pytorch.org/models/maskrcnn_resnet50_fpn_v2_coco-73cbd019.pth",
+ transforms=ObjectDetection,
+ meta={
+ **_COMMON_META,
+ "num_params": 46359409,
+ "recipe": "https://github.com/pytorch/vision/pull/5773",
+ "_metrics": {
+ "COCO-val2017": {
+ "box_map": 47.4,
+ "mask_map": 41.8,
+ }
+ },
+ "_ops": 333.577,
+ "_file_size": 177.219,
+ "_docs": """These weights were produced using an enhanced training recipe to boost the model accuracy.""",
+ },
+ )
+ DEFAULT = COCO_V1
+
+
+@register_model()
+@handle_legacy_interface(
+ weights=("pretrained", MaskRCNN_ResNet50_FPN_Weights.COCO_V1),
+ weights_backbone=("pretrained_backbone", ResNet50_Weights.IMAGENET1K_V1),
+)
+def maskrcnn_resnet50_fpn(
+ *,
+ weights: Optional[MaskRCNN_ResNet50_FPN_Weights] = None,
+ progress: bool = True,
+ num_classes: Optional[int] = None,
+ weights_backbone: Optional[ResNet50_Weights] = ResNet50_Weights.IMAGENET1K_V1,
+ trainable_backbone_layers: Optional[int] = None,
+ **kwargs: Any,
+) -> MaskRCNN:
+ """Mask R-CNN model with a ResNet-50-FPN backbone from the `Mask R-CNN
+ `_ paper.
+
+ .. betastatus:: detection module
+
+ The input to the model is expected to be a list of tensors, each of shape ``[C, H, W]``, one for each
+ image, and should be in ``0-1`` range. Different images can have different sizes.
+
+ The behavior of the model changes depending on if it is in training or evaluation mode.
+
+ During training, the model expects both the input tensors and targets (list of dictionary),
+ containing:
+
+ - boxes (``FloatTensor[N, 4]``): the ground-truth boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (``Int64Tensor[N]``): the class label for each ground-truth box
+ - masks (``UInt8Tensor[N, H, W]``): the segmentation binary masks for each instance
+
+ The model returns a ``Dict[Tensor]`` during training, containing the classification and regression
+ losses for both the RPN and the R-CNN, and the mask loss.
+
+ During inference, the model requires only the input tensors, and returns the post-processed
+ predictions as a ``List[Dict[Tensor]]``, one for each input image. The fields of the ``Dict`` are as
+ follows, where ``N`` is the number of detected instances:
+
+ - boxes (``FloatTensor[N, 4]``): the predicted boxes in ``[x1, y1, x2, y2]`` format, with
+ ``0 <= x1 < x2 <= W`` and ``0 <= y1 < y2 <= H``.
+ - labels (``Int64Tensor[N]``): the predicted labels for each instance
+ - scores (``Tensor[N]``): the scores or each instance
+ - masks (``UInt8Tensor[N, 1, H, W]``): the predicted masks for each instance, in ``0-1`` range. In order to
+ obtain the final segmentation masks, the soft masks can be thresholded, generally
+ with a value of 0.5 (``mask >= 0.5``)
+
+ For more details on the output and on how to plot the masks, you may refer to :ref:`instance_seg_output`.
+
+ Mask R-CNN is exportable to ONNX for a fixed batch size with inputs images of fixed size.
+
+ Example::
+
+ >>> model = torchvision.models.detection.maskrcnn_resnet50_fpn(weights=MaskRCNN_ResNet50_FPN_Weights.DEFAULT)
+ >>> model.eval()
+ >>> x = [torch.rand(3, 300, 400), torch.rand(3, 500, 400)]
+ >>> predictions = model(x)
+ >>>
+ >>> # optionally, if you want to export the model to ONNX:
+ >>> torch.onnx.export(model, x, "mask_rcnn.onnx", opset_version = 11)
+
+ Args:
+ weights (:class:`~torchvision.models.detection.MaskRCNN_ResNet50_FPN_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.detection.MaskRCNN_ResNet50_FPN_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ num_classes (int, optional): number of output classes of the model (including the background)
+ weights_backbone (:class:`~torchvision.models.ResNet50_Weights`, optional): The
+ pretrained weights for the backbone.
+ trainable_backbone_layers (int, optional): number of trainable (not frozen) layers starting from
+ final block. Valid values are between 0 and 5, with 5 meaning all backbone layers are
+ trainable. If ``None`` is passed (the default) this value is set to 3.
+ **kwargs: parameters passed to the ``torchvision.models.detection.mask_rcnn.MaskRCNN``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.detection.MaskRCNN_ResNet50_FPN_Weights
+ :members:
+ """
+ weights = MaskRCNN_ResNet50_FPN_Weights.verify(weights)
+ weights_backbone = ResNet50_Weights.verify(weights_backbone)
+
+ if weights is not None:
+ weights_backbone = None
+ num_classes = _ovewrite_value_param("num_classes", num_classes, len(weights.meta["categories"]))
+ elif num_classes is None:
+ num_classes = 91
+
+ is_trained = weights is not None or weights_backbone is not None
+ trainable_backbone_layers = _validate_trainable_layers(is_trained, trainable_backbone_layers, 5, 3)
+ norm_layer = misc_nn_ops.FrozenBatchNorm2d if is_trained else nn.BatchNorm2d
+
+ backbone = resnet50(weights=weights_backbone, progress=progress, norm_layer=norm_layer)
+ backbone = _resnet_fpn_extractor(backbone, trainable_backbone_layers)
+ model = MaskRCNN(backbone, num_classes=num_classes, **kwargs)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+ if weights == MaskRCNN_ResNet50_FPN_Weights.COCO_V1:
+ overwrite_eps(model, 0.0)
+
+ return model
+
+
+@register_model()
+@handle_legacy_interface(
+ weights=("pretrained", MaskRCNN_ResNet50_FPN_V2_Weights.COCO_V1),
+ weights_backbone=("pretrained_backbone", ResNet50_Weights.IMAGENET1K_V1),
+)
+def maskrcnn_resnet50_fpn_v2(
+ *,
+ weights: Optional[MaskRCNN_ResNet50_FPN_V2_Weights] = None,
+ progress: bool = True,
+ num_classes: Optional[int] = None,
+ weights_backbone: Optional[ResNet50_Weights] = None,
+ trainable_backbone_layers: Optional[int] = None,
+ **kwargs: Any,
+) -> MaskRCNN:
+ """Improved Mask R-CNN model with a ResNet-50-FPN backbone from the `Benchmarking Detection Transfer
+ Learning with Vision Transformers `_ paper.
+
+ .. betastatus:: detection module
+
+ :func:`~torchvision.models.detection.maskrcnn_resnet50_fpn` for more details.
+
+ Args:
+ weights (:class:`~torchvision.models.detection.MaskRCNN_ResNet50_FPN_V2_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.detection.MaskRCNN_ResNet50_FPN_V2_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ num_classes (int, optional): number of output classes of the model (including the background)
+ weights_backbone (:class:`~torchvision.models.ResNet50_Weights`, optional): The
+ pretrained weights for the backbone.
+ trainable_backbone_layers (int, optional): number of trainable (not frozen) layers starting from
+ final block. Valid values are between 0 and 5, with 5 meaning all backbone layers are
+ trainable. If ``None`` is passed (the default) this value is set to 3.
+ **kwargs: parameters passed to the ``torchvision.models.detection.mask_rcnn.MaskRCNN``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.detection.MaskRCNN_ResNet50_FPN_V2_Weights
+ :members:
+ """
+ weights = MaskRCNN_ResNet50_FPN_V2_Weights.verify(weights)
+ weights_backbone = ResNet50_Weights.verify(weights_backbone)
+
+ if weights is not None:
+ weights_backbone = None
+ num_classes = _ovewrite_value_param("num_classes", num_classes, len(weights.meta["categories"]))
+ elif num_classes is None:
+ num_classes = 91
+
+ is_trained = weights is not None or weights_backbone is not None
+ trainable_backbone_layers = _validate_trainable_layers(is_trained, trainable_backbone_layers, 5, 3)
+
+ backbone = resnet50(weights=weights_backbone, progress=progress)
+ backbone = _resnet_fpn_extractor(backbone, trainable_backbone_layers, norm_layer=nn.BatchNorm2d)
+ rpn_anchor_generator = _default_anchorgen()
+ rpn_head = RPNHead(backbone.out_channels, rpn_anchor_generator.num_anchors_per_location()[0], conv_depth=2)
+ box_head = FastRCNNConvFCHead(
+ (backbone.out_channels, 7, 7), [256, 256, 256, 256], [1024], norm_layer=nn.BatchNorm2d
+ )
+ mask_head = MaskRCNNHeads(backbone.out_channels, [256, 256, 256, 256], 1, norm_layer=nn.BatchNorm2d)
+ model = MaskRCNN(
+ backbone,
+ num_classes=num_classes,
+ rpn_anchor_generator=rpn_anchor_generator,
+ rpn_head=rpn_head,
+ box_head=box_head,
+ mask_head=mask_head,
+ **kwargs,
+ )
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/detection/rpn.py b/wemm/lib/python3.10/site-packages/torchvision/models/detection/rpn.py
new file mode 100644
index 0000000000000000000000000000000000000000..07a8b931150ae2dc9c89098c78422a3907a829d1
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/detection/rpn.py
@@ -0,0 +1,387 @@
+from typing import Dict, List, Optional, Tuple
+
+import torch
+from torch import nn, Tensor
+from torch.nn import functional as F
+from torchvision.ops import boxes as box_ops, Conv2dNormActivation
+
+from . import _utils as det_utils
+
+# Import AnchorGenerator to keep compatibility.
+from .anchor_utils import AnchorGenerator # noqa: 401
+from .image_list import ImageList
+
+
+class RPNHead(nn.Module):
+ """
+ Adds a simple RPN Head with classification and regression heads
+
+ Args:
+ in_channels (int): number of channels of the input feature
+ num_anchors (int): number of anchors to be predicted
+ conv_depth (int, optional): number of convolutions
+ """
+
+ _version = 2
+
+ def __init__(self, in_channels: int, num_anchors: int, conv_depth=1) -> None:
+ super().__init__()
+ convs = []
+ for _ in range(conv_depth):
+ convs.append(Conv2dNormActivation(in_channels, in_channels, kernel_size=3, norm_layer=None))
+ self.conv = nn.Sequential(*convs)
+ self.cls_logits = nn.Conv2d(in_channels, num_anchors, kernel_size=1, stride=1)
+ self.bbox_pred = nn.Conv2d(in_channels, num_anchors * 4, kernel_size=1, stride=1)
+
+ for layer in self.modules():
+ if isinstance(layer, nn.Conv2d):
+ torch.nn.init.normal_(layer.weight, std=0.01) # type: ignore[arg-type]
+ if layer.bias is not None:
+ torch.nn.init.constant_(layer.bias, 0) # type: ignore[arg-type]
+
+ def _load_from_state_dict(
+ self,
+ state_dict,
+ prefix,
+ local_metadata,
+ strict,
+ missing_keys,
+ unexpected_keys,
+ error_msgs,
+ ):
+ version = local_metadata.get("version", None)
+
+ if version is None or version < 2:
+ for type in ["weight", "bias"]:
+ old_key = f"{prefix}conv.{type}"
+ new_key = f"{prefix}conv.0.0.{type}"
+ if old_key in state_dict:
+ state_dict[new_key] = state_dict.pop(old_key)
+
+ super()._load_from_state_dict(
+ state_dict,
+ prefix,
+ local_metadata,
+ strict,
+ missing_keys,
+ unexpected_keys,
+ error_msgs,
+ )
+
+ def forward(self, x: List[Tensor]) -> Tuple[List[Tensor], List[Tensor]]:
+ logits = []
+ bbox_reg = []
+ for feature in x:
+ t = self.conv(feature)
+ logits.append(self.cls_logits(t))
+ bbox_reg.append(self.bbox_pred(t))
+ return logits, bbox_reg
+
+
+def permute_and_flatten(layer: Tensor, N: int, A: int, C: int, H: int, W: int) -> Tensor:
+ layer = layer.view(N, -1, C, H, W)
+ layer = layer.permute(0, 3, 4, 1, 2)
+ layer = layer.reshape(N, -1, C)
+ return layer
+
+
+def concat_box_prediction_layers(box_cls: List[Tensor], box_regression: List[Tensor]) -> Tuple[Tensor, Tensor]:
+ box_cls_flattened = []
+ box_regression_flattened = []
+ # for each feature level, permute the outputs to make them be in the
+ # same format as the labels. Note that the labels are computed for
+ # all feature levels concatenated, so we keep the same representation
+ # for the objectness and the box_regression
+ for box_cls_per_level, box_regression_per_level in zip(box_cls, box_regression):
+ N, AxC, H, W = box_cls_per_level.shape
+ Ax4 = box_regression_per_level.shape[1]
+ A = Ax4 // 4
+ C = AxC // A
+ box_cls_per_level = permute_and_flatten(box_cls_per_level, N, A, C, H, W)
+ box_cls_flattened.append(box_cls_per_level)
+
+ box_regression_per_level = permute_and_flatten(box_regression_per_level, N, A, 4, H, W)
+ box_regression_flattened.append(box_regression_per_level)
+ # concatenate on the first dimension (representing the feature levels), to
+ # take into account the way the labels were generated (with all feature maps
+ # being concatenated as well)
+ box_cls = torch.cat(box_cls_flattened, dim=1).flatten(0, -2)
+ box_regression = torch.cat(box_regression_flattened, dim=1).reshape(-1, 4)
+ return box_cls, box_regression
+
+
+class RegionProposalNetwork(torch.nn.Module):
+ """
+ Implements Region Proposal Network (RPN).
+
+ Args:
+ anchor_generator (AnchorGenerator): module that generates the anchors for a set of feature
+ maps.
+ head (nn.Module): module that computes the objectness and regression deltas
+ fg_iou_thresh (float): minimum IoU between the anchor and the GT box so that they can be
+ considered as positive during training of the RPN.
+ bg_iou_thresh (float): maximum IoU between the anchor and the GT box so that they can be
+ considered as negative during training of the RPN.
+ batch_size_per_image (int): number of anchors that are sampled during training of the RPN
+ for computing the loss
+ positive_fraction (float): proportion of positive anchors in a mini-batch during training
+ of the RPN
+ pre_nms_top_n (Dict[str, int]): number of proposals to keep before applying NMS. It should
+ contain two fields: training and testing, to allow for different values depending
+ on training or evaluation
+ post_nms_top_n (Dict[str, int]): number of proposals to keep after applying NMS. It should
+ contain two fields: training and testing, to allow for different values depending
+ on training or evaluation
+ nms_thresh (float): NMS threshold used for postprocessing the RPN proposals
+
+ """
+
+ __annotations__ = {
+ "box_coder": det_utils.BoxCoder,
+ "proposal_matcher": det_utils.Matcher,
+ "fg_bg_sampler": det_utils.BalancedPositiveNegativeSampler,
+ }
+
+ def __init__(
+ self,
+ anchor_generator: AnchorGenerator,
+ head: nn.Module,
+ # Faster-RCNN Training
+ fg_iou_thresh: float,
+ bg_iou_thresh: float,
+ batch_size_per_image: int,
+ positive_fraction: float,
+ # Faster-RCNN Inference
+ pre_nms_top_n: Dict[str, int],
+ post_nms_top_n: Dict[str, int],
+ nms_thresh: float,
+ score_thresh: float = 0.0,
+ ) -> None:
+ super().__init__()
+ self.anchor_generator = anchor_generator
+ self.head = head
+ self.box_coder = det_utils.BoxCoder(weights=(1.0, 1.0, 1.0, 1.0))
+
+ # used during training
+ self.box_similarity = box_ops.box_iou
+
+ self.proposal_matcher = det_utils.Matcher(
+ fg_iou_thresh,
+ bg_iou_thresh,
+ allow_low_quality_matches=True,
+ )
+
+ self.fg_bg_sampler = det_utils.BalancedPositiveNegativeSampler(batch_size_per_image, positive_fraction)
+ # used during testing
+ self._pre_nms_top_n = pre_nms_top_n
+ self._post_nms_top_n = post_nms_top_n
+ self.nms_thresh = nms_thresh
+ self.score_thresh = score_thresh
+ self.min_size = 1e-3
+
+ def pre_nms_top_n(self) -> int:
+ if self.training:
+ return self._pre_nms_top_n["training"]
+ return self._pre_nms_top_n["testing"]
+
+ def post_nms_top_n(self) -> int:
+ if self.training:
+ return self._post_nms_top_n["training"]
+ return self._post_nms_top_n["testing"]
+
+ def assign_targets_to_anchors(
+ self, anchors: List[Tensor], targets: List[Dict[str, Tensor]]
+ ) -> Tuple[List[Tensor], List[Tensor]]:
+
+ labels = []
+ matched_gt_boxes = []
+ for anchors_per_image, targets_per_image in zip(anchors, targets):
+ gt_boxes = targets_per_image["boxes"]
+
+ if gt_boxes.numel() == 0:
+ # Background image (negative example)
+ device = anchors_per_image.device
+ matched_gt_boxes_per_image = torch.zeros(anchors_per_image.shape, dtype=torch.float32, device=device)
+ labels_per_image = torch.zeros((anchors_per_image.shape[0],), dtype=torch.float32, device=device)
+ else:
+ match_quality_matrix = self.box_similarity(gt_boxes, anchors_per_image)
+ matched_idxs = self.proposal_matcher(match_quality_matrix)
+ # get the targets corresponding GT for each proposal
+ # NB: need to clamp the indices because we can have a single
+ # GT in the image, and matched_idxs can be -2, which goes
+ # out of bounds
+ matched_gt_boxes_per_image = gt_boxes[matched_idxs.clamp(min=0)]
+
+ labels_per_image = matched_idxs >= 0
+ labels_per_image = labels_per_image.to(dtype=torch.float32)
+
+ # Background (negative examples)
+ bg_indices = matched_idxs == self.proposal_matcher.BELOW_LOW_THRESHOLD
+ labels_per_image[bg_indices] = 0.0
+
+ # discard indices that are between thresholds
+ inds_to_discard = matched_idxs == self.proposal_matcher.BETWEEN_THRESHOLDS
+ labels_per_image[inds_to_discard] = -1.0
+
+ labels.append(labels_per_image)
+ matched_gt_boxes.append(matched_gt_boxes_per_image)
+ return labels, matched_gt_boxes
+
+ def _get_top_n_idx(self, objectness: Tensor, num_anchors_per_level: List[int]) -> Tensor:
+ r = []
+ offset = 0
+ for ob in objectness.split(num_anchors_per_level, 1):
+ num_anchors = ob.shape[1]
+ pre_nms_top_n = det_utils._topk_min(ob, self.pre_nms_top_n(), 1)
+ _, top_n_idx = ob.topk(pre_nms_top_n, dim=1)
+ r.append(top_n_idx + offset)
+ offset += num_anchors
+ return torch.cat(r, dim=1)
+
+ def filter_proposals(
+ self,
+ proposals: Tensor,
+ objectness: Tensor,
+ image_shapes: List[Tuple[int, int]],
+ num_anchors_per_level: List[int],
+ ) -> Tuple[List[Tensor], List[Tensor]]:
+
+ num_images = proposals.shape[0]
+ device = proposals.device
+ # do not backprop through objectness
+ objectness = objectness.detach()
+ objectness = objectness.reshape(num_images, -1)
+
+ levels = [
+ torch.full((n,), idx, dtype=torch.int64, device=device) for idx, n in enumerate(num_anchors_per_level)
+ ]
+ levels = torch.cat(levels, 0)
+ levels = levels.reshape(1, -1).expand_as(objectness)
+
+ # select top_n boxes independently per level before applying nms
+ top_n_idx = self._get_top_n_idx(objectness, num_anchors_per_level)
+
+ image_range = torch.arange(num_images, device=device)
+ batch_idx = image_range[:, None]
+
+ objectness = objectness[batch_idx, top_n_idx]
+ levels = levels[batch_idx, top_n_idx]
+ proposals = proposals[batch_idx, top_n_idx]
+
+ objectness_prob = torch.sigmoid(objectness)
+
+ final_boxes = []
+ final_scores = []
+ for boxes, scores, lvl, img_shape in zip(proposals, objectness_prob, levels, image_shapes):
+ boxes = box_ops.clip_boxes_to_image(boxes, img_shape)
+
+ # remove small boxes
+ keep = box_ops.remove_small_boxes(boxes, self.min_size)
+ boxes, scores, lvl = boxes[keep], scores[keep], lvl[keep]
+
+ # remove low scoring boxes
+ # use >= for Backwards compatibility
+ keep = torch.where(scores >= self.score_thresh)[0]
+ boxes, scores, lvl = boxes[keep], scores[keep], lvl[keep]
+
+ # non-maximum suppression, independently done per level
+ keep = box_ops.batched_nms(boxes, scores, lvl, self.nms_thresh)
+
+ # keep only topk scoring predictions
+ keep = keep[: self.post_nms_top_n()]
+ boxes, scores = boxes[keep], scores[keep]
+
+ final_boxes.append(boxes)
+ final_scores.append(scores)
+ return final_boxes, final_scores
+
+ def compute_loss(
+ self, objectness: Tensor, pred_bbox_deltas: Tensor, labels: List[Tensor], regression_targets: List[Tensor]
+ ) -> Tuple[Tensor, Tensor]:
+ """
+ Args:
+ objectness (Tensor)
+ pred_bbox_deltas (Tensor)
+ labels (List[Tensor])
+ regression_targets (List[Tensor])
+
+ Returns:
+ objectness_loss (Tensor)
+ box_loss (Tensor)
+ """
+
+ sampled_pos_inds, sampled_neg_inds = self.fg_bg_sampler(labels)
+ sampled_pos_inds = torch.where(torch.cat(sampled_pos_inds, dim=0))[0]
+ sampled_neg_inds = torch.where(torch.cat(sampled_neg_inds, dim=0))[0]
+
+ sampled_inds = torch.cat([sampled_pos_inds, sampled_neg_inds], dim=0)
+
+ objectness = objectness.flatten()
+
+ labels = torch.cat(labels, dim=0)
+ regression_targets = torch.cat(regression_targets, dim=0)
+
+ box_loss = F.smooth_l1_loss(
+ pred_bbox_deltas[sampled_pos_inds],
+ regression_targets[sampled_pos_inds],
+ beta=1 / 9,
+ reduction="sum",
+ ) / (sampled_inds.numel())
+
+ objectness_loss = F.binary_cross_entropy_with_logits(objectness[sampled_inds], labels[sampled_inds])
+
+ return objectness_loss, box_loss
+
+ def forward(
+ self,
+ images: ImageList,
+ features: Dict[str, Tensor],
+ targets: Optional[List[Dict[str, Tensor]]] = None,
+ ) -> Tuple[List[Tensor], Dict[str, Tensor]]:
+
+ """
+ Args:
+ images (ImageList): images for which we want to compute the predictions
+ features (Dict[str, Tensor]): features computed from the images that are
+ used for computing the predictions. Each tensor in the list
+ correspond to different feature levels
+ targets (List[Dict[str, Tensor]]): ground-truth boxes present in the image (optional).
+ If provided, each element in the dict should contain a field `boxes`,
+ with the locations of the ground-truth boxes.
+
+ Returns:
+ boxes (List[Tensor]): the predicted boxes from the RPN, one Tensor per
+ image.
+ losses (Dict[str, Tensor]): the losses for the model during training. During
+ testing, it is an empty dict.
+ """
+ # RPN uses all feature maps that are available
+ features = list(features.values())
+ objectness, pred_bbox_deltas = self.head(features)
+ anchors = self.anchor_generator(images, features)
+
+ num_images = len(anchors)
+ num_anchors_per_level_shape_tensors = [o[0].shape for o in objectness]
+ num_anchors_per_level = [s[0] * s[1] * s[2] for s in num_anchors_per_level_shape_tensors]
+ objectness, pred_bbox_deltas = concat_box_prediction_layers(objectness, pred_bbox_deltas)
+ # apply pred_bbox_deltas to anchors to obtain the decoded proposals
+ # note that we detach the deltas because Faster R-CNN do not backprop through
+ # the proposals
+ proposals = self.box_coder.decode(pred_bbox_deltas.detach(), anchors)
+ proposals = proposals.view(num_images, -1, 4)
+ boxes, scores = self.filter_proposals(proposals, objectness, images.image_sizes, num_anchors_per_level)
+
+ losses = {}
+ if self.training:
+ if targets is None:
+ raise ValueError("targets should not be None")
+ labels, matched_gt_boxes = self.assign_targets_to_anchors(anchors, targets)
+ regression_targets = self.box_coder.encode(matched_gt_boxes, anchors)
+ loss_objectness, loss_rpn_box_reg = self.compute_loss(
+ objectness, pred_bbox_deltas, labels, regression_targets
+ )
+ losses = {
+ "loss_objectness": loss_objectness,
+ "loss_rpn_box_reg": loss_rpn_box_reg,
+ }
+ return boxes, losses
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/inception.py b/wemm/lib/python3.10/site-packages/torchvision/models/inception.py
new file mode 100644
index 0000000000000000000000000000000000000000..f7b00d4925549f66bf31dfdebe76aba4b75ccf55
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/inception.py
@@ -0,0 +1,478 @@
+import warnings
+from collections import namedtuple
+from functools import partial
+from typing import Any, Callable, List, Optional, Tuple
+
+import torch
+import torch.nn.functional as F
+from torch import nn, Tensor
+
+from ..transforms._presets import ImageClassification
+from ..utils import _log_api_usage_once
+from ._api import register_model, Weights, WeightsEnum
+from ._meta import _IMAGENET_CATEGORIES
+from ._utils import _ovewrite_named_param, handle_legacy_interface
+
+
+__all__ = ["Inception3", "InceptionOutputs", "_InceptionOutputs", "Inception_V3_Weights", "inception_v3"]
+
+
+InceptionOutputs = namedtuple("InceptionOutputs", ["logits", "aux_logits"])
+InceptionOutputs.__annotations__ = {"logits": Tensor, "aux_logits": Optional[Tensor]}
+
+# Script annotations failed with _GoogleNetOutputs = namedtuple ...
+# _InceptionOutputs set here for backwards compat
+_InceptionOutputs = InceptionOutputs
+
+
+class Inception3(nn.Module):
+ def __init__(
+ self,
+ num_classes: int = 1000,
+ aux_logits: bool = True,
+ transform_input: bool = False,
+ inception_blocks: Optional[List[Callable[..., nn.Module]]] = None,
+ init_weights: Optional[bool] = None,
+ dropout: float = 0.5,
+ ) -> None:
+ super().__init__()
+ _log_api_usage_once(self)
+ if inception_blocks is None:
+ inception_blocks = [BasicConv2d, InceptionA, InceptionB, InceptionC, InceptionD, InceptionE, InceptionAux]
+ if init_weights is None:
+ warnings.warn(
+ "The default weight initialization of inception_v3 will be changed in future releases of "
+ "torchvision. If you wish to keep the old behavior (which leads to long initialization times"
+ " due to scipy/scipy#11299), please set init_weights=True.",
+ FutureWarning,
+ )
+ init_weights = True
+ if len(inception_blocks) != 7:
+ raise ValueError(f"length of inception_blocks should be 7 instead of {len(inception_blocks)}")
+ conv_block = inception_blocks[0]
+ inception_a = inception_blocks[1]
+ inception_b = inception_blocks[2]
+ inception_c = inception_blocks[3]
+ inception_d = inception_blocks[4]
+ inception_e = inception_blocks[5]
+ inception_aux = inception_blocks[6]
+
+ self.aux_logits = aux_logits
+ self.transform_input = transform_input
+ self.Conv2d_1a_3x3 = conv_block(3, 32, kernel_size=3, stride=2)
+ self.Conv2d_2a_3x3 = conv_block(32, 32, kernel_size=3)
+ self.Conv2d_2b_3x3 = conv_block(32, 64, kernel_size=3, padding=1)
+ self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2)
+ self.Conv2d_3b_1x1 = conv_block(64, 80, kernel_size=1)
+ self.Conv2d_4a_3x3 = conv_block(80, 192, kernel_size=3)
+ self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2)
+ self.Mixed_5b = inception_a(192, pool_features=32)
+ self.Mixed_5c = inception_a(256, pool_features=64)
+ self.Mixed_5d = inception_a(288, pool_features=64)
+ self.Mixed_6a = inception_b(288)
+ self.Mixed_6b = inception_c(768, channels_7x7=128)
+ self.Mixed_6c = inception_c(768, channels_7x7=160)
+ self.Mixed_6d = inception_c(768, channels_7x7=160)
+ self.Mixed_6e = inception_c(768, channels_7x7=192)
+ self.AuxLogits: Optional[nn.Module] = None
+ if aux_logits:
+ self.AuxLogits = inception_aux(768, num_classes)
+ self.Mixed_7a = inception_d(768)
+ self.Mixed_7b = inception_e(1280)
+ self.Mixed_7c = inception_e(2048)
+ self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+ self.dropout = nn.Dropout(p=dropout)
+ self.fc = nn.Linear(2048, num_classes)
+ if init_weights:
+ for m in self.modules():
+ if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear):
+ stddev = float(m.stddev) if hasattr(m, "stddev") else 0.1 # type: ignore
+ torch.nn.init.trunc_normal_(m.weight, mean=0.0, std=stddev, a=-2, b=2)
+ elif isinstance(m, nn.BatchNorm2d):
+ nn.init.constant_(m.weight, 1)
+ nn.init.constant_(m.bias, 0)
+
+ def _transform_input(self, x: Tensor) -> Tensor:
+ if self.transform_input:
+ x_ch0 = torch.unsqueeze(x[:, 0], 1) * (0.229 / 0.5) + (0.485 - 0.5) / 0.5
+ x_ch1 = torch.unsqueeze(x[:, 1], 1) * (0.224 / 0.5) + (0.456 - 0.5) / 0.5
+ x_ch2 = torch.unsqueeze(x[:, 2], 1) * (0.225 / 0.5) + (0.406 - 0.5) / 0.5
+ x = torch.cat((x_ch0, x_ch1, x_ch2), 1)
+ return x
+
+ def _forward(self, x: Tensor) -> Tuple[Tensor, Optional[Tensor]]:
+ # N x 3 x 299 x 299
+ x = self.Conv2d_1a_3x3(x)
+ # N x 32 x 149 x 149
+ x = self.Conv2d_2a_3x3(x)
+ # N x 32 x 147 x 147
+ x = self.Conv2d_2b_3x3(x)
+ # N x 64 x 147 x 147
+ x = self.maxpool1(x)
+ # N x 64 x 73 x 73
+ x = self.Conv2d_3b_1x1(x)
+ # N x 80 x 73 x 73
+ x = self.Conv2d_4a_3x3(x)
+ # N x 192 x 71 x 71
+ x = self.maxpool2(x)
+ # N x 192 x 35 x 35
+ x = self.Mixed_5b(x)
+ # N x 256 x 35 x 35
+ x = self.Mixed_5c(x)
+ # N x 288 x 35 x 35
+ x = self.Mixed_5d(x)
+ # N x 288 x 35 x 35
+ x = self.Mixed_6a(x)
+ # N x 768 x 17 x 17
+ x = self.Mixed_6b(x)
+ # N x 768 x 17 x 17
+ x = self.Mixed_6c(x)
+ # N x 768 x 17 x 17
+ x = self.Mixed_6d(x)
+ # N x 768 x 17 x 17
+ x = self.Mixed_6e(x)
+ # N x 768 x 17 x 17
+ aux: Optional[Tensor] = None
+ if self.AuxLogits is not None:
+ if self.training:
+ aux = self.AuxLogits(x)
+ # N x 768 x 17 x 17
+ x = self.Mixed_7a(x)
+ # N x 1280 x 8 x 8
+ x = self.Mixed_7b(x)
+ # N x 2048 x 8 x 8
+ x = self.Mixed_7c(x)
+ # N x 2048 x 8 x 8
+ # Adaptive average pooling
+ x = self.avgpool(x)
+ # N x 2048 x 1 x 1
+ x = self.dropout(x)
+ # N x 2048 x 1 x 1
+ x = torch.flatten(x, 1)
+ # N x 2048
+ x = self.fc(x)
+ # N x 1000 (num_classes)
+ return x, aux
+
+ @torch.jit.unused
+ def eager_outputs(self, x: Tensor, aux: Optional[Tensor]) -> InceptionOutputs:
+ if self.training and self.aux_logits:
+ return InceptionOutputs(x, aux)
+ else:
+ return x # type: ignore[return-value]
+
+ def forward(self, x: Tensor) -> InceptionOutputs:
+ x = self._transform_input(x)
+ x, aux = self._forward(x)
+ aux_defined = self.training and self.aux_logits
+ if torch.jit.is_scripting():
+ if not aux_defined:
+ warnings.warn("Scripted Inception3 always returns Inception3 Tuple")
+ return InceptionOutputs(x, aux)
+ else:
+ return self.eager_outputs(x, aux)
+
+
+class InceptionA(nn.Module):
+ def __init__(
+ self, in_channels: int, pool_features: int, conv_block: Optional[Callable[..., nn.Module]] = None
+ ) -> None:
+ super().__init__()
+ if conv_block is None:
+ conv_block = BasicConv2d
+ self.branch1x1 = conv_block(in_channels, 64, kernel_size=1)
+
+ self.branch5x5_1 = conv_block(in_channels, 48, kernel_size=1)
+ self.branch5x5_2 = conv_block(48, 64, kernel_size=5, padding=2)
+
+ self.branch3x3dbl_1 = conv_block(in_channels, 64, kernel_size=1)
+ self.branch3x3dbl_2 = conv_block(64, 96, kernel_size=3, padding=1)
+ self.branch3x3dbl_3 = conv_block(96, 96, kernel_size=3, padding=1)
+
+ self.branch_pool = conv_block(in_channels, pool_features, kernel_size=1)
+
+ def _forward(self, x: Tensor) -> List[Tensor]:
+ branch1x1 = self.branch1x1(x)
+
+ branch5x5 = self.branch5x5_1(x)
+ branch5x5 = self.branch5x5_2(branch5x5)
+
+ branch3x3dbl = self.branch3x3dbl_1(x)
+ branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
+ branch3x3dbl = self.branch3x3dbl_3(branch3x3dbl)
+
+ branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
+ branch_pool = self.branch_pool(branch_pool)
+
+ outputs = [branch1x1, branch5x5, branch3x3dbl, branch_pool]
+ return outputs
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return torch.cat(outputs, 1)
+
+
+class InceptionB(nn.Module):
+ def __init__(self, in_channels: int, conv_block: Optional[Callable[..., nn.Module]] = None) -> None:
+ super().__init__()
+ if conv_block is None:
+ conv_block = BasicConv2d
+ self.branch3x3 = conv_block(in_channels, 384, kernel_size=3, stride=2)
+
+ self.branch3x3dbl_1 = conv_block(in_channels, 64, kernel_size=1)
+ self.branch3x3dbl_2 = conv_block(64, 96, kernel_size=3, padding=1)
+ self.branch3x3dbl_3 = conv_block(96, 96, kernel_size=3, stride=2)
+
+ def _forward(self, x: Tensor) -> List[Tensor]:
+ branch3x3 = self.branch3x3(x)
+
+ branch3x3dbl = self.branch3x3dbl_1(x)
+ branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
+ branch3x3dbl = self.branch3x3dbl_3(branch3x3dbl)
+
+ branch_pool = F.max_pool2d(x, kernel_size=3, stride=2)
+
+ outputs = [branch3x3, branch3x3dbl, branch_pool]
+ return outputs
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return torch.cat(outputs, 1)
+
+
+class InceptionC(nn.Module):
+ def __init__(
+ self, in_channels: int, channels_7x7: int, conv_block: Optional[Callable[..., nn.Module]] = None
+ ) -> None:
+ super().__init__()
+ if conv_block is None:
+ conv_block = BasicConv2d
+ self.branch1x1 = conv_block(in_channels, 192, kernel_size=1)
+
+ c7 = channels_7x7
+ self.branch7x7_1 = conv_block(in_channels, c7, kernel_size=1)
+ self.branch7x7_2 = conv_block(c7, c7, kernel_size=(1, 7), padding=(0, 3))
+ self.branch7x7_3 = conv_block(c7, 192, kernel_size=(7, 1), padding=(3, 0))
+
+ self.branch7x7dbl_1 = conv_block(in_channels, c7, kernel_size=1)
+ self.branch7x7dbl_2 = conv_block(c7, c7, kernel_size=(7, 1), padding=(3, 0))
+ self.branch7x7dbl_3 = conv_block(c7, c7, kernel_size=(1, 7), padding=(0, 3))
+ self.branch7x7dbl_4 = conv_block(c7, c7, kernel_size=(7, 1), padding=(3, 0))
+ self.branch7x7dbl_5 = conv_block(c7, 192, kernel_size=(1, 7), padding=(0, 3))
+
+ self.branch_pool = conv_block(in_channels, 192, kernel_size=1)
+
+ def _forward(self, x: Tensor) -> List[Tensor]:
+ branch1x1 = self.branch1x1(x)
+
+ branch7x7 = self.branch7x7_1(x)
+ branch7x7 = self.branch7x7_2(branch7x7)
+ branch7x7 = self.branch7x7_3(branch7x7)
+
+ branch7x7dbl = self.branch7x7dbl_1(x)
+ branch7x7dbl = self.branch7x7dbl_2(branch7x7dbl)
+ branch7x7dbl = self.branch7x7dbl_3(branch7x7dbl)
+ branch7x7dbl = self.branch7x7dbl_4(branch7x7dbl)
+ branch7x7dbl = self.branch7x7dbl_5(branch7x7dbl)
+
+ branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
+ branch_pool = self.branch_pool(branch_pool)
+
+ outputs = [branch1x1, branch7x7, branch7x7dbl, branch_pool]
+ return outputs
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return torch.cat(outputs, 1)
+
+
+class InceptionD(nn.Module):
+ def __init__(self, in_channels: int, conv_block: Optional[Callable[..., nn.Module]] = None) -> None:
+ super().__init__()
+ if conv_block is None:
+ conv_block = BasicConv2d
+ self.branch3x3_1 = conv_block(in_channels, 192, kernel_size=1)
+ self.branch3x3_2 = conv_block(192, 320, kernel_size=3, stride=2)
+
+ self.branch7x7x3_1 = conv_block(in_channels, 192, kernel_size=1)
+ self.branch7x7x3_2 = conv_block(192, 192, kernel_size=(1, 7), padding=(0, 3))
+ self.branch7x7x3_3 = conv_block(192, 192, kernel_size=(7, 1), padding=(3, 0))
+ self.branch7x7x3_4 = conv_block(192, 192, kernel_size=3, stride=2)
+
+ def _forward(self, x: Tensor) -> List[Tensor]:
+ branch3x3 = self.branch3x3_1(x)
+ branch3x3 = self.branch3x3_2(branch3x3)
+
+ branch7x7x3 = self.branch7x7x3_1(x)
+ branch7x7x3 = self.branch7x7x3_2(branch7x7x3)
+ branch7x7x3 = self.branch7x7x3_3(branch7x7x3)
+ branch7x7x3 = self.branch7x7x3_4(branch7x7x3)
+
+ branch_pool = F.max_pool2d(x, kernel_size=3, stride=2)
+ outputs = [branch3x3, branch7x7x3, branch_pool]
+ return outputs
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return torch.cat(outputs, 1)
+
+
+class InceptionE(nn.Module):
+ def __init__(self, in_channels: int, conv_block: Optional[Callable[..., nn.Module]] = None) -> None:
+ super().__init__()
+ if conv_block is None:
+ conv_block = BasicConv2d
+ self.branch1x1 = conv_block(in_channels, 320, kernel_size=1)
+
+ self.branch3x3_1 = conv_block(in_channels, 384, kernel_size=1)
+ self.branch3x3_2a = conv_block(384, 384, kernel_size=(1, 3), padding=(0, 1))
+ self.branch3x3_2b = conv_block(384, 384, kernel_size=(3, 1), padding=(1, 0))
+
+ self.branch3x3dbl_1 = conv_block(in_channels, 448, kernel_size=1)
+ self.branch3x3dbl_2 = conv_block(448, 384, kernel_size=3, padding=1)
+ self.branch3x3dbl_3a = conv_block(384, 384, kernel_size=(1, 3), padding=(0, 1))
+ self.branch3x3dbl_3b = conv_block(384, 384, kernel_size=(3, 1), padding=(1, 0))
+
+ self.branch_pool = conv_block(in_channels, 192, kernel_size=1)
+
+ def _forward(self, x: Tensor) -> List[Tensor]:
+ branch1x1 = self.branch1x1(x)
+
+ branch3x3 = self.branch3x3_1(x)
+ branch3x3 = [
+ self.branch3x3_2a(branch3x3),
+ self.branch3x3_2b(branch3x3),
+ ]
+ branch3x3 = torch.cat(branch3x3, 1)
+
+ branch3x3dbl = self.branch3x3dbl_1(x)
+ branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
+ branch3x3dbl = [
+ self.branch3x3dbl_3a(branch3x3dbl),
+ self.branch3x3dbl_3b(branch3x3dbl),
+ ]
+ branch3x3dbl = torch.cat(branch3x3dbl, 1)
+
+ branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
+ branch_pool = self.branch_pool(branch_pool)
+
+ outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool]
+ return outputs
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return torch.cat(outputs, 1)
+
+
+class InceptionAux(nn.Module):
+ def __init__(
+ self, in_channels: int, num_classes: int, conv_block: Optional[Callable[..., nn.Module]] = None
+ ) -> None:
+ super().__init__()
+ if conv_block is None:
+ conv_block = BasicConv2d
+ self.conv0 = conv_block(in_channels, 128, kernel_size=1)
+ self.conv1 = conv_block(128, 768, kernel_size=5)
+ self.conv1.stddev = 0.01 # type: ignore[assignment]
+ self.fc = nn.Linear(768, num_classes)
+ self.fc.stddev = 0.001 # type: ignore[assignment]
+
+ def forward(self, x: Tensor) -> Tensor:
+ # N x 768 x 17 x 17
+ x = F.avg_pool2d(x, kernel_size=5, stride=3)
+ # N x 768 x 5 x 5
+ x = self.conv0(x)
+ # N x 128 x 5 x 5
+ x = self.conv1(x)
+ # N x 768 x 1 x 1
+ # Adaptive average pooling
+ x = F.adaptive_avg_pool2d(x, (1, 1))
+ # N x 768 x 1 x 1
+ x = torch.flatten(x, 1)
+ # N x 768
+ x = self.fc(x)
+ # N x 1000
+ return x
+
+
+class BasicConv2d(nn.Module):
+ def __init__(self, in_channels: int, out_channels: int, **kwargs: Any) -> None:
+ super().__init__()
+ self.conv = nn.Conv2d(in_channels, out_channels, bias=False, **kwargs)
+ self.bn = nn.BatchNorm2d(out_channels, eps=0.001)
+
+ def forward(self, x: Tensor) -> Tensor:
+ x = self.conv(x)
+ x = self.bn(x)
+ return F.relu(x, inplace=True)
+
+
+class Inception_V3_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/inception_v3_google-0cc3c7bd.pth",
+ transforms=partial(ImageClassification, crop_size=299, resize_size=342),
+ meta={
+ "num_params": 27161264,
+ "min_size": (75, 75),
+ "categories": _IMAGENET_CATEGORIES,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#inception-v3",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 77.294,
+ "acc@5": 93.450,
+ }
+ },
+ "_ops": 5.713,
+ "_file_size": 103.903,
+ "_docs": """These weights are ported from the original paper.""",
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", Inception_V3_Weights.IMAGENET1K_V1))
+def inception_v3(*, weights: Optional[Inception_V3_Weights] = None, progress: bool = True, **kwargs: Any) -> Inception3:
+ """
+ Inception v3 model architecture from
+ `Rethinking the Inception Architecture for Computer Vision `_.
+
+ .. note::
+ **Important**: In contrast to the other models the inception_v3 expects tensors with a size of
+ N x 3 x 299 x 299, so ensure your images are sized accordingly.
+
+ Args:
+ weights (:class:`~torchvision.models.Inception_V3_Weights`, optional): The
+ pretrained weights for the model. See
+ :class:`~torchvision.models.Inception_V3_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.Inception3``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.Inception_V3_Weights
+ :members:
+ """
+ weights = Inception_V3_Weights.verify(weights)
+
+ original_aux_logits = kwargs.get("aux_logits", True)
+ if weights is not None:
+ if "transform_input" not in kwargs:
+ _ovewrite_named_param(kwargs, "transform_input", True)
+ _ovewrite_named_param(kwargs, "aux_logits", True)
+ _ovewrite_named_param(kwargs, "init_weights", False)
+ _ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"]))
+
+ model = Inception3(**kwargs)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+ if not original_aux_logits:
+ model.aux_logits = False
+ model.AuxLogits = None
+
+ return model
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/maxvit.py b/wemm/lib/python3.10/site-packages/torchvision/models/maxvit.py
new file mode 100644
index 0000000000000000000000000000000000000000..633be4d4eae5fa836b6e86b4353145843e174b7d
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/maxvit.py
@@ -0,0 +1,832 @@
+import math
+from collections import OrderedDict
+from functools import partial
+from typing import Any, Callable, List, Optional, Sequence, Tuple
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch import nn, Tensor
+from torchvision.models._api import register_model, Weights, WeightsEnum
+from torchvision.models._meta import _IMAGENET_CATEGORIES
+from torchvision.models._utils import _ovewrite_named_param, handle_legacy_interface
+from torchvision.ops.misc import Conv2dNormActivation, SqueezeExcitation
+from torchvision.ops.stochastic_depth import StochasticDepth
+from torchvision.transforms._presets import ImageClassification, InterpolationMode
+from torchvision.utils import _log_api_usage_once
+
+__all__ = [
+ "MaxVit",
+ "MaxVit_T_Weights",
+ "maxvit_t",
+]
+
+
+def _get_conv_output_shape(input_size: Tuple[int, int], kernel_size: int, stride: int, padding: int) -> Tuple[int, int]:
+ return (
+ (input_size[0] - kernel_size + 2 * padding) // stride + 1,
+ (input_size[1] - kernel_size + 2 * padding) // stride + 1,
+ )
+
+
+def _make_block_input_shapes(input_size: Tuple[int, int], n_blocks: int) -> List[Tuple[int, int]]:
+ """Util function to check that the input size is correct for a MaxVit configuration."""
+ shapes = []
+ block_input_shape = _get_conv_output_shape(input_size, 3, 2, 1)
+ for _ in range(n_blocks):
+ block_input_shape = _get_conv_output_shape(block_input_shape, 3, 2, 1)
+ shapes.append(block_input_shape)
+ return shapes
+
+
+def _get_relative_position_index(height: int, width: int) -> torch.Tensor:
+ coords = torch.stack(torch.meshgrid([torch.arange(height), torch.arange(width)]))
+ coords_flat = torch.flatten(coords, 1)
+ relative_coords = coords_flat[:, :, None] - coords_flat[:, None, :]
+ relative_coords = relative_coords.permute(1, 2, 0).contiguous()
+ relative_coords[:, :, 0] += height - 1
+ relative_coords[:, :, 1] += width - 1
+ relative_coords[:, :, 0] *= 2 * width - 1
+ return relative_coords.sum(-1)
+
+
+class MBConv(nn.Module):
+ """MBConv: Mobile Inverted Residual Bottleneck.
+
+ Args:
+ in_channels (int): Number of input channels.
+ out_channels (int): Number of output channels.
+ expansion_ratio (float): Expansion ratio in the bottleneck.
+ squeeze_ratio (float): Squeeze ratio in the SE Layer.
+ stride (int): Stride of the depthwise convolution.
+ activation_layer (Callable[..., nn.Module]): Activation function.
+ norm_layer (Callable[..., nn.Module]): Normalization function.
+ p_stochastic_dropout (float): Probability of stochastic depth.
+ """
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ expansion_ratio: float,
+ squeeze_ratio: float,
+ stride: int,
+ activation_layer: Callable[..., nn.Module],
+ norm_layer: Callable[..., nn.Module],
+ p_stochastic_dropout: float = 0.0,
+ ) -> None:
+ super().__init__()
+
+ proj: Sequence[nn.Module]
+ self.proj: nn.Module
+
+ should_proj = stride != 1 or in_channels != out_channels
+ if should_proj:
+ proj = [nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, bias=True)]
+ if stride == 2:
+ proj = [nn.AvgPool2d(kernel_size=3, stride=stride, padding=1)] + proj # type: ignore
+ self.proj = nn.Sequential(*proj)
+ else:
+ self.proj = nn.Identity() # type: ignore
+
+ mid_channels = int(out_channels * expansion_ratio)
+ sqz_channels = int(out_channels * squeeze_ratio)
+
+ if p_stochastic_dropout:
+ self.stochastic_depth = StochasticDepth(p_stochastic_dropout, mode="row") # type: ignore
+ else:
+ self.stochastic_depth = nn.Identity() # type: ignore
+
+ _layers = OrderedDict()
+ _layers["pre_norm"] = norm_layer(in_channels)
+ _layers["conv_a"] = Conv2dNormActivation(
+ in_channels,
+ mid_channels,
+ kernel_size=1,
+ stride=1,
+ padding=0,
+ activation_layer=activation_layer,
+ norm_layer=norm_layer,
+ inplace=None,
+ )
+ _layers["conv_b"] = Conv2dNormActivation(
+ mid_channels,
+ mid_channels,
+ kernel_size=3,
+ stride=stride,
+ padding=1,
+ activation_layer=activation_layer,
+ norm_layer=norm_layer,
+ groups=mid_channels,
+ inplace=None,
+ )
+ _layers["squeeze_excitation"] = SqueezeExcitation(mid_channels, sqz_channels, activation=nn.SiLU)
+ _layers["conv_c"] = nn.Conv2d(in_channels=mid_channels, out_channels=out_channels, kernel_size=1, bias=True)
+
+ self.layers = nn.Sequential(_layers)
+
+ def forward(self, x: Tensor) -> Tensor:
+ """
+ Args:
+ x (Tensor): Input tensor with expected layout of [B, C, H, W].
+ Returns:
+ Tensor: Output tensor with expected layout of [B, C, H / stride, W / stride].
+ """
+ res = self.proj(x)
+ x = self.stochastic_depth(self.layers(x))
+ return res + x
+
+
+class RelativePositionalMultiHeadAttention(nn.Module):
+ """Relative Positional Multi-Head Attention.
+
+ Args:
+ feat_dim (int): Number of input features.
+ head_dim (int): Number of features per head.
+ max_seq_len (int): Maximum sequence length.
+ """
+
+ def __init__(
+ self,
+ feat_dim: int,
+ head_dim: int,
+ max_seq_len: int,
+ ) -> None:
+ super().__init__()
+
+ if feat_dim % head_dim != 0:
+ raise ValueError(f"feat_dim: {feat_dim} must be divisible by head_dim: {head_dim}")
+
+ self.n_heads = feat_dim // head_dim
+ self.head_dim = head_dim
+ self.size = int(math.sqrt(max_seq_len))
+ self.max_seq_len = max_seq_len
+
+ self.to_qkv = nn.Linear(feat_dim, self.n_heads * self.head_dim * 3)
+ self.scale_factor = feat_dim**-0.5
+
+ self.merge = nn.Linear(self.head_dim * self.n_heads, feat_dim)
+ self.relative_position_bias_table = nn.parameter.Parameter(
+ torch.empty(((2 * self.size - 1) * (2 * self.size - 1), self.n_heads), dtype=torch.float32),
+ )
+
+ self.register_buffer("relative_position_index", _get_relative_position_index(self.size, self.size))
+ # initialize with truncated normal the bias
+ torch.nn.init.trunc_normal_(self.relative_position_bias_table, std=0.02)
+
+ def get_relative_positional_bias(self) -> torch.Tensor:
+ bias_index = self.relative_position_index.view(-1) # type: ignore
+ relative_bias = self.relative_position_bias_table[bias_index].view(self.max_seq_len, self.max_seq_len, -1) # type: ignore
+ relative_bias = relative_bias.permute(2, 0, 1).contiguous()
+ return relative_bias.unsqueeze(0)
+
+ def forward(self, x: Tensor) -> Tensor:
+ """
+ Args:
+ x (Tensor): Input tensor with expected layout of [B, G, P, D].
+ Returns:
+ Tensor: Output tensor with expected layout of [B, G, P, D].
+ """
+ B, G, P, D = x.shape
+ H, DH = self.n_heads, self.head_dim
+
+ qkv = self.to_qkv(x)
+ q, k, v = torch.chunk(qkv, 3, dim=-1)
+
+ q = q.reshape(B, G, P, H, DH).permute(0, 1, 3, 2, 4)
+ k = k.reshape(B, G, P, H, DH).permute(0, 1, 3, 2, 4)
+ v = v.reshape(B, G, P, H, DH).permute(0, 1, 3, 2, 4)
+
+ k = k * self.scale_factor
+ dot_prod = torch.einsum("B G H I D, B G H J D -> B G H I J", q, k)
+ pos_bias = self.get_relative_positional_bias()
+
+ dot_prod = F.softmax(dot_prod + pos_bias, dim=-1)
+
+ out = torch.einsum("B G H I J, B G H J D -> B G H I D", dot_prod, v)
+ out = out.permute(0, 1, 3, 2, 4).reshape(B, G, P, D)
+
+ out = self.merge(out)
+ return out
+
+
+class SwapAxes(nn.Module):
+ """Permute the axes of a tensor."""
+
+ def __init__(self, a: int, b: int) -> None:
+ super().__init__()
+ self.a = a
+ self.b = b
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ res = torch.swapaxes(x, self.a, self.b)
+ return res
+
+
+class WindowPartition(nn.Module):
+ """
+ Partition the input tensor into non-overlapping windows.
+ """
+
+ def __init__(self) -> None:
+ super().__init__()
+
+ def forward(self, x: Tensor, p: int) -> Tensor:
+ """
+ Args:
+ x (Tensor): Input tensor with expected layout of [B, C, H, W].
+ p (int): Number of partitions.
+ Returns:
+ Tensor: Output tensor with expected layout of [B, H/P, W/P, P*P, C].
+ """
+ B, C, H, W = x.shape
+ P = p
+ # chunk up H and W dimensions
+ x = x.reshape(B, C, H // P, P, W // P, P)
+ x = x.permute(0, 2, 4, 3, 5, 1)
+ # colapse P * P dimension
+ x = x.reshape(B, (H // P) * (W // P), P * P, C)
+ return x
+
+
+class WindowDepartition(nn.Module):
+ """
+ Departition the input tensor of non-overlapping windows into a feature volume of layout [B, C, H, W].
+ """
+
+ def __init__(self) -> None:
+ super().__init__()
+
+ def forward(self, x: Tensor, p: int, h_partitions: int, w_partitions: int) -> Tensor:
+ """
+ Args:
+ x (Tensor): Input tensor with expected layout of [B, (H/P * W/P), P*P, C].
+ p (int): Number of partitions.
+ h_partitions (int): Number of vertical partitions.
+ w_partitions (int): Number of horizontal partitions.
+ Returns:
+ Tensor: Output tensor with expected layout of [B, C, H, W].
+ """
+ B, G, PP, C = x.shape
+ P = p
+ HP, WP = h_partitions, w_partitions
+ # split P * P dimension into 2 P tile dimensionsa
+ x = x.reshape(B, HP, WP, P, P, C)
+ # permute into B, C, HP, P, WP, P
+ x = x.permute(0, 5, 1, 3, 2, 4)
+ # reshape into B, C, H, W
+ x = x.reshape(B, C, HP * P, WP * P)
+ return x
+
+
+class PartitionAttentionLayer(nn.Module):
+ """
+ Layer for partitioning the input tensor into non-overlapping windows and applying attention to each window.
+
+ Args:
+ in_channels (int): Number of input channels.
+ head_dim (int): Dimension of each attention head.
+ partition_size (int): Size of the partitions.
+ partition_type (str): Type of partitioning to use. Can be either "grid" or "window".
+ grid_size (Tuple[int, int]): Size of the grid to partition the input tensor into.
+ mlp_ratio (int): Ratio of the feature size expansion in the MLP layer.
+ activation_layer (Callable[..., nn.Module]): Activation function to use.
+ norm_layer (Callable[..., nn.Module]): Normalization function to use.
+ attention_dropout (float): Dropout probability for the attention layer.
+ mlp_dropout (float): Dropout probability for the MLP layer.
+ p_stochastic_dropout (float): Probability of dropping out a partition.
+ """
+
+ def __init__(
+ self,
+ in_channels: int,
+ head_dim: int,
+ # partitioning parameters
+ partition_size: int,
+ partition_type: str,
+ # grid size needs to be known at initialization time
+ # because we need to know hamy relative offsets there are in the grid
+ grid_size: Tuple[int, int],
+ mlp_ratio: int,
+ activation_layer: Callable[..., nn.Module],
+ norm_layer: Callable[..., nn.Module],
+ attention_dropout: float,
+ mlp_dropout: float,
+ p_stochastic_dropout: float,
+ ) -> None:
+ super().__init__()
+
+ self.n_heads = in_channels // head_dim
+ self.head_dim = head_dim
+ self.n_partitions = grid_size[0] // partition_size
+ self.partition_type = partition_type
+ self.grid_size = grid_size
+
+ if partition_type not in ["grid", "window"]:
+ raise ValueError("partition_type must be either 'grid' or 'window'")
+
+ if partition_type == "window":
+ self.p, self.g = partition_size, self.n_partitions
+ else:
+ self.p, self.g = self.n_partitions, partition_size
+
+ self.partition_op = WindowPartition()
+ self.departition_op = WindowDepartition()
+ self.partition_swap = SwapAxes(-2, -3) if partition_type == "grid" else nn.Identity()
+ self.departition_swap = SwapAxes(-2, -3) if partition_type == "grid" else nn.Identity()
+
+ self.attn_layer = nn.Sequential(
+ norm_layer(in_channels),
+ # it's always going to be partition_size ** 2 because
+ # of the axis swap in the case of grid partitioning
+ RelativePositionalMultiHeadAttention(in_channels, head_dim, partition_size**2),
+ nn.Dropout(attention_dropout),
+ )
+
+ # pre-normalization similar to transformer layers
+ self.mlp_layer = nn.Sequential(
+ nn.LayerNorm(in_channels),
+ nn.Linear(in_channels, in_channels * mlp_ratio),
+ activation_layer(),
+ nn.Linear(in_channels * mlp_ratio, in_channels),
+ nn.Dropout(mlp_dropout),
+ )
+
+ # layer scale factors
+ self.stochastic_dropout = StochasticDepth(p_stochastic_dropout, mode="row")
+
+ def forward(self, x: Tensor) -> Tensor:
+ """
+ Args:
+ x (Tensor): Input tensor with expected layout of [B, C, H, W].
+ Returns:
+ Tensor: Output tensor with expected layout of [B, C, H, W].
+ """
+
+ # Undefined behavior if H or W are not divisible by p
+ # https://github.com/google-research/maxvit/blob/da76cf0d8a6ec668cc31b399c4126186da7da944/maxvit/models/maxvit.py#L766
+ gh, gw = self.grid_size[0] // self.p, self.grid_size[1] // self.p
+ torch._assert(
+ self.grid_size[0] % self.p == 0 and self.grid_size[1] % self.p == 0,
+ "Grid size must be divisible by partition size. Got grid size of {} and partition size of {}".format(
+ self.grid_size, self.p
+ ),
+ )
+
+ x = self.partition_op(x, self.p)
+ x = self.partition_swap(x)
+ x = x + self.stochastic_dropout(self.attn_layer(x))
+ x = x + self.stochastic_dropout(self.mlp_layer(x))
+ x = self.departition_swap(x)
+ x = self.departition_op(x, self.p, gh, gw)
+
+ return x
+
+
+class MaxVitLayer(nn.Module):
+ """
+ MaxVit layer consisting of a MBConv layer followed by a PartitionAttentionLayer with `window` and a PartitionAttentionLayer with `grid`.
+
+ Args:
+ in_channels (int): Number of input channels.
+ out_channels (int): Number of output channels.
+ expansion_ratio (float): Expansion ratio in the bottleneck.
+ squeeze_ratio (float): Squeeze ratio in the SE Layer.
+ stride (int): Stride of the depthwise convolution.
+ activation_layer (Callable[..., nn.Module]): Activation function.
+ norm_layer (Callable[..., nn.Module]): Normalization function.
+ head_dim (int): Dimension of the attention heads.
+ mlp_ratio (int): Ratio of the MLP layer.
+ mlp_dropout (float): Dropout probability for the MLP layer.
+ attention_dropout (float): Dropout probability for the attention layer.
+ p_stochastic_dropout (float): Probability of stochastic depth.
+ partition_size (int): Size of the partitions.
+ grid_size (Tuple[int, int]): Size of the input feature grid.
+ """
+
+ def __init__(
+ self,
+ # conv parameters
+ in_channels: int,
+ out_channels: int,
+ squeeze_ratio: float,
+ expansion_ratio: float,
+ stride: int,
+ # conv + transformer parameters
+ norm_layer: Callable[..., nn.Module],
+ activation_layer: Callable[..., nn.Module],
+ # transformer parameters
+ head_dim: int,
+ mlp_ratio: int,
+ mlp_dropout: float,
+ attention_dropout: float,
+ p_stochastic_dropout: float,
+ # partitioning parameters
+ partition_size: int,
+ grid_size: Tuple[int, int],
+ ) -> None:
+ super().__init__()
+
+ layers: OrderedDict = OrderedDict()
+
+ # convolutional layer
+ layers["MBconv"] = MBConv(
+ in_channels=in_channels,
+ out_channels=out_channels,
+ expansion_ratio=expansion_ratio,
+ squeeze_ratio=squeeze_ratio,
+ stride=stride,
+ activation_layer=activation_layer,
+ norm_layer=norm_layer,
+ p_stochastic_dropout=p_stochastic_dropout,
+ )
+ # attention layers, block -> grid
+ layers["window_attention"] = PartitionAttentionLayer(
+ in_channels=out_channels,
+ head_dim=head_dim,
+ partition_size=partition_size,
+ partition_type="window",
+ grid_size=grid_size,
+ mlp_ratio=mlp_ratio,
+ activation_layer=activation_layer,
+ norm_layer=nn.LayerNorm,
+ attention_dropout=attention_dropout,
+ mlp_dropout=mlp_dropout,
+ p_stochastic_dropout=p_stochastic_dropout,
+ )
+ layers["grid_attention"] = PartitionAttentionLayer(
+ in_channels=out_channels,
+ head_dim=head_dim,
+ partition_size=partition_size,
+ partition_type="grid",
+ grid_size=grid_size,
+ mlp_ratio=mlp_ratio,
+ activation_layer=activation_layer,
+ norm_layer=nn.LayerNorm,
+ attention_dropout=attention_dropout,
+ mlp_dropout=mlp_dropout,
+ p_stochastic_dropout=p_stochastic_dropout,
+ )
+ self.layers = nn.Sequential(layers)
+
+ def forward(self, x: Tensor) -> Tensor:
+ """
+ Args:
+ x (Tensor): Input tensor of shape (B, C, H, W).
+ Returns:
+ Tensor: Output tensor of shape (B, C, H, W).
+ """
+ x = self.layers(x)
+ return x
+
+
+class MaxVitBlock(nn.Module):
+ """
+ A MaxVit block consisting of `n_layers` MaxVit layers.
+
+ Args:
+ in_channels (int): Number of input channels.
+ out_channels (int): Number of output channels.
+ expansion_ratio (float): Expansion ratio in the bottleneck.
+ squeeze_ratio (float): Squeeze ratio in the SE Layer.
+ activation_layer (Callable[..., nn.Module]): Activation function.
+ norm_layer (Callable[..., nn.Module]): Normalization function.
+ head_dim (int): Dimension of the attention heads.
+ mlp_ratio (int): Ratio of the MLP layer.
+ mlp_dropout (float): Dropout probability for the MLP layer.
+ attention_dropout (float): Dropout probability for the attention layer.
+ p_stochastic_dropout (float): Probability of stochastic depth.
+ partition_size (int): Size of the partitions.
+ input_grid_size (Tuple[int, int]): Size of the input feature grid.
+ n_layers (int): Number of layers in the block.
+ p_stochastic (List[float]): List of probabilities for stochastic depth for each layer.
+ """
+
+ def __init__(
+ self,
+ # conv parameters
+ in_channels: int,
+ out_channels: int,
+ squeeze_ratio: float,
+ expansion_ratio: float,
+ # conv + transformer parameters
+ norm_layer: Callable[..., nn.Module],
+ activation_layer: Callable[..., nn.Module],
+ # transformer parameters
+ head_dim: int,
+ mlp_ratio: int,
+ mlp_dropout: float,
+ attention_dropout: float,
+ # partitioning parameters
+ partition_size: int,
+ input_grid_size: Tuple[int, int],
+ # number of layers
+ n_layers: int,
+ p_stochastic: List[float],
+ ) -> None:
+ super().__init__()
+ if not len(p_stochastic) == n_layers:
+ raise ValueError(f"p_stochastic must have length n_layers={n_layers}, got p_stochastic={p_stochastic}.")
+
+ self.layers = nn.ModuleList()
+ # account for the first stride of the first layer
+ self.grid_size = _get_conv_output_shape(input_grid_size, kernel_size=3, stride=2, padding=1)
+
+ for idx, p in enumerate(p_stochastic):
+ stride = 2 if idx == 0 else 1
+ self.layers += [
+ MaxVitLayer(
+ in_channels=in_channels if idx == 0 else out_channels,
+ out_channels=out_channels,
+ squeeze_ratio=squeeze_ratio,
+ expansion_ratio=expansion_ratio,
+ stride=stride,
+ norm_layer=norm_layer,
+ activation_layer=activation_layer,
+ head_dim=head_dim,
+ mlp_ratio=mlp_ratio,
+ mlp_dropout=mlp_dropout,
+ attention_dropout=attention_dropout,
+ partition_size=partition_size,
+ grid_size=self.grid_size,
+ p_stochastic_dropout=p,
+ ),
+ ]
+
+ def forward(self, x: Tensor) -> Tensor:
+ """
+ Args:
+ x (Tensor): Input tensor of shape (B, C, H, W).
+ Returns:
+ Tensor: Output tensor of shape (B, C, H, W).
+ """
+ for layer in self.layers:
+ x = layer(x)
+ return x
+
+
+class MaxVit(nn.Module):
+ """
+ Implements MaxVit Transformer from the `MaxViT: Multi-Axis Vision Transformer `_ paper.
+ Args:
+ input_size (Tuple[int, int]): Size of the input image.
+ stem_channels (int): Number of channels in the stem.
+ partition_size (int): Size of the partitions.
+ block_channels (List[int]): Number of channels in each block.
+ block_layers (List[int]): Number of layers in each block.
+ stochastic_depth_prob (float): Probability of stochastic depth. Expands to a list of probabilities for each layer that scales linearly to the specified value.
+ squeeze_ratio (float): Squeeze ratio in the SE Layer. Default: 0.25.
+ expansion_ratio (float): Expansion ratio in the MBConv bottleneck. Default: 4.
+ norm_layer (Callable[..., nn.Module]): Normalization function. Default: None (setting to None will produce a `BatchNorm2d(eps=1e-3, momentum=0.99)`).
+ activation_layer (Callable[..., nn.Module]): Activation function Default: nn.GELU.
+ head_dim (int): Dimension of the attention heads.
+ mlp_ratio (int): Expansion ratio of the MLP layer. Default: 4.
+ mlp_dropout (float): Dropout probability for the MLP layer. Default: 0.0.
+ attention_dropout (float): Dropout probability for the attention layer. Default: 0.0.
+ num_classes (int): Number of classes. Default: 1000.
+ """
+
+ def __init__(
+ self,
+ # input size parameters
+ input_size: Tuple[int, int],
+ # stem and task parameters
+ stem_channels: int,
+ # partitioning parameters
+ partition_size: int,
+ # block parameters
+ block_channels: List[int],
+ block_layers: List[int],
+ # attention head dimensions
+ head_dim: int,
+ stochastic_depth_prob: float,
+ # conv + transformer parameters
+ # norm_layer is applied only to the conv layers
+ # activation_layer is applied both to conv and transformer layers
+ norm_layer: Optional[Callable[..., nn.Module]] = None,
+ activation_layer: Callable[..., nn.Module] = nn.GELU,
+ # conv parameters
+ squeeze_ratio: float = 0.25,
+ expansion_ratio: float = 4,
+ # transformer parameters
+ mlp_ratio: int = 4,
+ mlp_dropout: float = 0.0,
+ attention_dropout: float = 0.0,
+ # task parameters
+ num_classes: int = 1000,
+ ) -> None:
+ super().__init__()
+ _log_api_usage_once(self)
+
+ input_channels = 3
+
+ # https://github.com/google-research/maxvit/blob/da76cf0d8a6ec668cc31b399c4126186da7da944/maxvit/models/maxvit.py#L1029-L1030
+ # for the exact parameters used in batchnorm
+ if norm_layer is None:
+ norm_layer = partial(nn.BatchNorm2d, eps=1e-3, momentum=0.99)
+
+ # Make sure input size will be divisible by the partition size in all blocks
+ # Undefined behavior if H or W are not divisible by p
+ # https://github.com/google-research/maxvit/blob/da76cf0d8a6ec668cc31b399c4126186da7da944/maxvit/models/maxvit.py#L766
+ block_input_sizes = _make_block_input_shapes(input_size, len(block_channels))
+ for idx, block_input_size in enumerate(block_input_sizes):
+ if block_input_size[0] % partition_size != 0 or block_input_size[1] % partition_size != 0:
+ raise ValueError(
+ f"Input size {block_input_size} of block {idx} is not divisible by partition size {partition_size}. "
+ f"Consider changing the partition size or the input size.\n"
+ f"Current configuration yields the following block input sizes: {block_input_sizes}."
+ )
+
+ # stem
+ self.stem = nn.Sequential(
+ Conv2dNormActivation(
+ input_channels,
+ stem_channels,
+ 3,
+ stride=2,
+ norm_layer=norm_layer,
+ activation_layer=activation_layer,
+ bias=False,
+ inplace=None,
+ ),
+ Conv2dNormActivation(
+ stem_channels, stem_channels, 3, stride=1, norm_layer=None, activation_layer=None, bias=True
+ ),
+ )
+
+ # account for stem stride
+ input_size = _get_conv_output_shape(input_size, kernel_size=3, stride=2, padding=1)
+ self.partition_size = partition_size
+
+ # blocks
+ self.blocks = nn.ModuleList()
+ in_channels = [stem_channels] + block_channels[:-1]
+ out_channels = block_channels
+
+ # precompute the stochastich depth probabilities from 0 to stochastic_depth_prob
+ # since we have N blocks with L layers, we will have N * L probabilities uniformly distributed
+ # over the range [0, stochastic_depth_prob]
+ p_stochastic = np.linspace(0, stochastic_depth_prob, sum(block_layers)).tolist()
+
+ p_idx = 0
+ for in_channel, out_channel, num_layers in zip(in_channels, out_channels, block_layers):
+ self.blocks.append(
+ MaxVitBlock(
+ in_channels=in_channel,
+ out_channels=out_channel,
+ squeeze_ratio=squeeze_ratio,
+ expansion_ratio=expansion_ratio,
+ norm_layer=norm_layer,
+ activation_layer=activation_layer,
+ head_dim=head_dim,
+ mlp_ratio=mlp_ratio,
+ mlp_dropout=mlp_dropout,
+ attention_dropout=attention_dropout,
+ partition_size=partition_size,
+ input_grid_size=input_size,
+ n_layers=num_layers,
+ p_stochastic=p_stochastic[p_idx : p_idx + num_layers],
+ ),
+ )
+ input_size = self.blocks[-1].grid_size
+ p_idx += num_layers
+
+ # see https://github.com/google-research/maxvit/blob/da76cf0d8a6ec668cc31b399c4126186da7da944/maxvit/models/maxvit.py#L1137-L1158
+ # for why there is Linear -> Tanh -> Linear
+ self.classifier = nn.Sequential(
+ nn.AdaptiveAvgPool2d(1),
+ nn.Flatten(),
+ nn.LayerNorm(block_channels[-1]),
+ nn.Linear(block_channels[-1], block_channels[-1]),
+ nn.Tanh(),
+ nn.Linear(block_channels[-1], num_classes, bias=False),
+ )
+
+ self._init_weights()
+
+ def forward(self, x: Tensor) -> Tensor:
+ x = self.stem(x)
+ for block in self.blocks:
+ x = block(x)
+ x = self.classifier(x)
+ return x
+
+ def _init_weights(self):
+ for m in self.modules():
+ if isinstance(m, nn.Conv2d):
+ nn.init.normal_(m.weight, std=0.02)
+ if m.bias is not None:
+ nn.init.zeros_(m.bias)
+ elif isinstance(m, nn.BatchNorm2d):
+ nn.init.constant_(m.weight, 1)
+ nn.init.constant_(m.bias, 0)
+ elif isinstance(m, nn.Linear):
+ nn.init.normal_(m.weight, std=0.02)
+ if m.bias is not None:
+ nn.init.zeros_(m.bias)
+
+
+def _maxvit(
+ # stem parameters
+ stem_channels: int,
+ # block parameters
+ block_channels: List[int],
+ block_layers: List[int],
+ stochastic_depth_prob: float,
+ # partitioning parameters
+ partition_size: int,
+ # transformer parameters
+ head_dim: int,
+ # Weights API
+ weights: Optional[WeightsEnum] = None,
+ progress: bool = False,
+ # kwargs,
+ **kwargs: Any,
+) -> MaxVit:
+
+ if weights is not None:
+ _ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"]))
+ assert weights.meta["min_size"][0] == weights.meta["min_size"][1]
+ _ovewrite_named_param(kwargs, "input_size", weights.meta["min_size"])
+
+ input_size = kwargs.pop("input_size", (224, 224))
+
+ model = MaxVit(
+ stem_channels=stem_channels,
+ block_channels=block_channels,
+ block_layers=block_layers,
+ stochastic_depth_prob=stochastic_depth_prob,
+ head_dim=head_dim,
+ partition_size=partition_size,
+ input_size=input_size,
+ **kwargs,
+ )
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
+
+
+class MaxVit_T_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ # URL empty until official release
+ url="https://download.pytorch.org/models/maxvit_t-bc5ab103.pth",
+ transforms=partial(
+ ImageClassification, crop_size=224, resize_size=224, interpolation=InterpolationMode.BICUBIC
+ ),
+ meta={
+ "categories": _IMAGENET_CATEGORIES,
+ "num_params": 30919624,
+ "min_size": (224, 224),
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#maxvit",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 83.700,
+ "acc@5": 96.722,
+ }
+ },
+ "_ops": 5.558,
+ "_file_size": 118.769,
+ "_docs": """These weights reproduce closely the results of the paper using a similar training recipe.""",
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", MaxVit_T_Weights.IMAGENET1K_V1))
+def maxvit_t(*, weights: Optional[MaxVit_T_Weights] = None, progress: bool = True, **kwargs: Any) -> MaxVit:
+ """
+ Constructs a maxvit_t architecture from
+ `MaxViT: Multi-Axis Vision Transformer `_.
+
+ Args:
+ weights (:class:`~torchvision.models.MaxVit_T_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.MaxVit_T_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.maxvit.MaxVit``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.MaxVit_T_Weights
+ :members:
+ """
+ weights = MaxVit_T_Weights.verify(weights)
+
+ return _maxvit(
+ stem_channels=64,
+ block_channels=[64, 128, 256, 512],
+ block_layers=[2, 2, 5, 2],
+ head_dim=32,
+ stochastic_depth_prob=0.2,
+ partition_size=7,
+ weights=weights,
+ progress=progress,
+ **kwargs,
+ )
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/mnasnet.py b/wemm/lib/python3.10/site-packages/torchvision/models/mnasnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..4b501b72102cf7b0c1f70cdd4d3e808f1a147155
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/mnasnet.py
@@ -0,0 +1,434 @@
+import warnings
+from functools import partial
+from typing import Any, Dict, List, Optional
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+
+from ..transforms._presets import ImageClassification
+from ..utils import _log_api_usage_once
+from ._api import register_model, Weights, WeightsEnum
+from ._meta import _IMAGENET_CATEGORIES
+from ._utils import _ovewrite_named_param, handle_legacy_interface
+
+
+__all__ = [
+ "MNASNet",
+ "MNASNet0_5_Weights",
+ "MNASNet0_75_Weights",
+ "MNASNet1_0_Weights",
+ "MNASNet1_3_Weights",
+ "mnasnet0_5",
+ "mnasnet0_75",
+ "mnasnet1_0",
+ "mnasnet1_3",
+]
+
+
+# Paper suggests 0.9997 momentum, for TensorFlow. Equivalent PyTorch momentum is
+# 1.0 - tensorflow.
+_BN_MOMENTUM = 1 - 0.9997
+
+
+class _InvertedResidual(nn.Module):
+ def __init__(
+ self, in_ch: int, out_ch: int, kernel_size: int, stride: int, expansion_factor: int, bn_momentum: float = 0.1
+ ) -> None:
+ super().__init__()
+ if stride not in [1, 2]:
+ raise ValueError(f"stride should be 1 or 2 instead of {stride}")
+ if kernel_size not in [3, 5]:
+ raise ValueError(f"kernel_size should be 3 or 5 instead of {kernel_size}")
+ mid_ch = in_ch * expansion_factor
+ self.apply_residual = in_ch == out_ch and stride == 1
+ self.layers = nn.Sequential(
+ # Pointwise
+ nn.Conv2d(in_ch, mid_ch, 1, bias=False),
+ nn.BatchNorm2d(mid_ch, momentum=bn_momentum),
+ nn.ReLU(inplace=True),
+ # Depthwise
+ nn.Conv2d(mid_ch, mid_ch, kernel_size, padding=kernel_size // 2, stride=stride, groups=mid_ch, bias=False),
+ nn.BatchNorm2d(mid_ch, momentum=bn_momentum),
+ nn.ReLU(inplace=True),
+ # Linear pointwise. Note that there's no activation.
+ nn.Conv2d(mid_ch, out_ch, 1, bias=False),
+ nn.BatchNorm2d(out_ch, momentum=bn_momentum),
+ )
+
+ def forward(self, input: Tensor) -> Tensor:
+ if self.apply_residual:
+ return self.layers(input) + input
+ else:
+ return self.layers(input)
+
+
+def _stack(
+ in_ch: int, out_ch: int, kernel_size: int, stride: int, exp_factor: int, repeats: int, bn_momentum: float
+) -> nn.Sequential:
+ """Creates a stack of inverted residuals."""
+ if repeats < 1:
+ raise ValueError(f"repeats should be >= 1, instead got {repeats}")
+ # First one has no skip, because feature map size changes.
+ first = _InvertedResidual(in_ch, out_ch, kernel_size, stride, exp_factor, bn_momentum=bn_momentum)
+ remaining = []
+ for _ in range(1, repeats):
+ remaining.append(_InvertedResidual(out_ch, out_ch, kernel_size, 1, exp_factor, bn_momentum=bn_momentum))
+ return nn.Sequential(first, *remaining)
+
+
+def _round_to_multiple_of(val: float, divisor: int, round_up_bias: float = 0.9) -> int:
+ """Asymmetric rounding to make `val` divisible by `divisor`. With default
+ bias, will round up, unless the number is no more than 10% greater than the
+ smaller divisible value, i.e. (83, 8) -> 80, but (84, 8) -> 88."""
+ if not 0.0 < round_up_bias < 1.0:
+ raise ValueError(f"round_up_bias should be greater than 0.0 and smaller than 1.0 instead of {round_up_bias}")
+ new_val = max(divisor, int(val + divisor / 2) // divisor * divisor)
+ return new_val if new_val >= round_up_bias * val else new_val + divisor
+
+
+def _get_depths(alpha: float) -> List[int]:
+ """Scales tensor depths as in reference MobileNet code, prefers rounding up
+ rather than down."""
+ depths = [32, 16, 24, 40, 80, 96, 192, 320]
+ return [_round_to_multiple_of(depth * alpha, 8) for depth in depths]
+
+
+class MNASNet(torch.nn.Module):
+ """MNASNet, as described in https://arxiv.org/pdf/1807.11626.pdf. This
+ implements the B1 variant of the model.
+ >>> model = MNASNet(1.0, num_classes=1000)
+ >>> x = torch.rand(1, 3, 224, 224)
+ >>> y = model(x)
+ >>> y.dim()
+ 2
+ >>> y.nelement()
+ 1000
+ """
+
+ # Version 2 adds depth scaling in the initial stages of the network.
+ _version = 2
+
+ def __init__(self, alpha: float, num_classes: int = 1000, dropout: float = 0.2) -> None:
+ super().__init__()
+ _log_api_usage_once(self)
+ if alpha <= 0.0:
+ raise ValueError(f"alpha should be greater than 0.0 instead of {alpha}")
+ self.alpha = alpha
+ self.num_classes = num_classes
+ depths = _get_depths(alpha)
+ layers = [
+ # First layer: regular conv.
+ nn.Conv2d(3, depths[0], 3, padding=1, stride=2, bias=False),
+ nn.BatchNorm2d(depths[0], momentum=_BN_MOMENTUM),
+ nn.ReLU(inplace=True),
+ # Depthwise separable, no skip.
+ nn.Conv2d(depths[0], depths[0], 3, padding=1, stride=1, groups=depths[0], bias=False),
+ nn.BatchNorm2d(depths[0], momentum=_BN_MOMENTUM),
+ nn.ReLU(inplace=True),
+ nn.Conv2d(depths[0], depths[1], 1, padding=0, stride=1, bias=False),
+ nn.BatchNorm2d(depths[1], momentum=_BN_MOMENTUM),
+ # MNASNet blocks: stacks of inverted residuals.
+ _stack(depths[1], depths[2], 3, 2, 3, 3, _BN_MOMENTUM),
+ _stack(depths[2], depths[3], 5, 2, 3, 3, _BN_MOMENTUM),
+ _stack(depths[3], depths[4], 5, 2, 6, 3, _BN_MOMENTUM),
+ _stack(depths[4], depths[5], 3, 1, 6, 2, _BN_MOMENTUM),
+ _stack(depths[5], depths[6], 5, 2, 6, 4, _BN_MOMENTUM),
+ _stack(depths[6], depths[7], 3, 1, 6, 1, _BN_MOMENTUM),
+ # Final mapping to classifier input.
+ nn.Conv2d(depths[7], 1280, 1, padding=0, stride=1, bias=False),
+ nn.BatchNorm2d(1280, momentum=_BN_MOMENTUM),
+ nn.ReLU(inplace=True),
+ ]
+ self.layers = nn.Sequential(*layers)
+ self.classifier = nn.Sequential(nn.Dropout(p=dropout, inplace=True), nn.Linear(1280, num_classes))
+
+ for m in self.modules():
+ if isinstance(m, nn.Conv2d):
+ nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+ if m.bias is not None:
+ nn.init.zeros_(m.bias)
+ elif isinstance(m, nn.BatchNorm2d):
+ nn.init.ones_(m.weight)
+ nn.init.zeros_(m.bias)
+ elif isinstance(m, nn.Linear):
+ nn.init.kaiming_uniform_(m.weight, mode="fan_out", nonlinearity="sigmoid")
+ nn.init.zeros_(m.bias)
+
+ def forward(self, x: Tensor) -> Tensor:
+ x = self.layers(x)
+ # Equivalent to global avgpool and removing H and W dimensions.
+ x = x.mean([2, 3])
+ return self.classifier(x)
+
+ def _load_from_state_dict(
+ self,
+ state_dict: Dict,
+ prefix: str,
+ local_metadata: Dict,
+ strict: bool,
+ missing_keys: List[str],
+ unexpected_keys: List[str],
+ error_msgs: List[str],
+ ) -> None:
+ version = local_metadata.get("version", None)
+ if version not in [1, 2]:
+ raise ValueError(f"version shluld be set to 1 or 2 instead of {version}")
+
+ if version == 1 and not self.alpha == 1.0:
+ # In the initial version of the model (v1), stem was fixed-size.
+ # All other layer configurations were the same. This will patch
+ # the model so that it's identical to v1. Model with alpha 1.0 is
+ # unaffected.
+ depths = _get_depths(self.alpha)
+ v1_stem = [
+ nn.Conv2d(3, 32, 3, padding=1, stride=2, bias=False),
+ nn.BatchNorm2d(32, momentum=_BN_MOMENTUM),
+ nn.ReLU(inplace=True),
+ nn.Conv2d(32, 32, 3, padding=1, stride=1, groups=32, bias=False),
+ nn.BatchNorm2d(32, momentum=_BN_MOMENTUM),
+ nn.ReLU(inplace=True),
+ nn.Conv2d(32, 16, 1, padding=0, stride=1, bias=False),
+ nn.BatchNorm2d(16, momentum=_BN_MOMENTUM),
+ _stack(16, depths[2], 3, 2, 3, 3, _BN_MOMENTUM),
+ ]
+ for idx, layer in enumerate(v1_stem):
+ self.layers[idx] = layer
+
+ # The model is now identical to v1, and must be saved as such.
+ self._version = 1
+ warnings.warn(
+ "A new version of MNASNet model has been implemented. "
+ "Your checkpoint was saved using the previous version. "
+ "This checkpoint will load and work as before, but "
+ "you may want to upgrade by training a newer model or "
+ "transfer learning from an updated ImageNet checkpoint.",
+ UserWarning,
+ )
+
+ super()._load_from_state_dict(
+ state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+ )
+
+
+_COMMON_META = {
+ "min_size": (1, 1),
+ "categories": _IMAGENET_CATEGORIES,
+ "recipe": "https://github.com/1e100/mnasnet_trainer",
+}
+
+
+class MNASNet0_5_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/mnasnet0.5_top1_67.823-3ffadce67e.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 2218512,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 67.734,
+ "acc@5": 87.490,
+ }
+ },
+ "_ops": 0.104,
+ "_file_size": 8.591,
+ "_docs": """These weights reproduce closely the results of the paper.""",
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+class MNASNet0_75_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/mnasnet0_75-7090bc5f.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "recipe": "https://github.com/pytorch/vision/pull/6019",
+ "num_params": 3170208,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 71.180,
+ "acc@5": 90.496,
+ }
+ },
+ "_ops": 0.215,
+ "_file_size": 12.303,
+ "_docs": """
+ These weights were trained from scratch by using TorchVision's `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+class MNASNet1_0_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/mnasnet1.0_top1_73.512-f206786ef8.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 4383312,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 73.456,
+ "acc@5": 91.510,
+ }
+ },
+ "_ops": 0.314,
+ "_file_size": 16.915,
+ "_docs": """These weights reproduce closely the results of the paper.""",
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+class MNASNet1_3_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/mnasnet1_3-a4c69d6f.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "recipe": "https://github.com/pytorch/vision/pull/6019",
+ "num_params": 6282256,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 76.506,
+ "acc@5": 93.522,
+ }
+ },
+ "_ops": 0.526,
+ "_file_size": 24.246,
+ "_docs": """
+ These weights were trained from scratch by using TorchVision's `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+def _mnasnet(alpha: float, weights: Optional[WeightsEnum], progress: bool, **kwargs: Any) -> MNASNet:
+ if weights is not None:
+ _ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"]))
+
+ model = MNASNet(alpha, **kwargs)
+
+ if weights:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", MNASNet0_5_Weights.IMAGENET1K_V1))
+def mnasnet0_5(*, weights: Optional[MNASNet0_5_Weights] = None, progress: bool = True, **kwargs: Any) -> MNASNet:
+ """MNASNet with depth multiplier of 0.5 from
+ `MnasNet: Platform-Aware Neural Architecture Search for Mobile
+ `_ paper.
+
+ Args:
+ weights (:class:`~torchvision.models.MNASNet0_5_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.MNASNet0_5_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.mnasnet.MNASNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.MNASNet0_5_Weights
+ :members:
+ """
+ weights = MNASNet0_5_Weights.verify(weights)
+
+ return _mnasnet(0.5, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", MNASNet0_75_Weights.IMAGENET1K_V1))
+def mnasnet0_75(*, weights: Optional[MNASNet0_75_Weights] = None, progress: bool = True, **kwargs: Any) -> MNASNet:
+ """MNASNet with depth multiplier of 0.75 from
+ `MnasNet: Platform-Aware Neural Architecture Search for Mobile
+ `_ paper.
+
+ Args:
+ weights (:class:`~torchvision.models.MNASNet0_75_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.MNASNet0_75_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.mnasnet.MNASNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.MNASNet0_75_Weights
+ :members:
+ """
+ weights = MNASNet0_75_Weights.verify(weights)
+
+ return _mnasnet(0.75, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", MNASNet1_0_Weights.IMAGENET1K_V1))
+def mnasnet1_0(*, weights: Optional[MNASNet1_0_Weights] = None, progress: bool = True, **kwargs: Any) -> MNASNet:
+ """MNASNet with depth multiplier of 1.0 from
+ `MnasNet: Platform-Aware Neural Architecture Search for Mobile
+ `_ paper.
+
+ Args:
+ weights (:class:`~torchvision.models.MNASNet1_0_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.MNASNet1_0_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.mnasnet.MNASNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.MNASNet1_0_Weights
+ :members:
+ """
+ weights = MNASNet1_0_Weights.verify(weights)
+
+ return _mnasnet(1.0, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", MNASNet1_3_Weights.IMAGENET1K_V1))
+def mnasnet1_3(*, weights: Optional[MNASNet1_3_Weights] = None, progress: bool = True, **kwargs: Any) -> MNASNet:
+ """MNASNet with depth multiplier of 1.3 from
+ `MnasNet: Platform-Aware Neural Architecture Search for Mobile
+ `_ paper.
+
+ Args:
+ weights (:class:`~torchvision.models.MNASNet1_3_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.MNASNet1_3_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.mnasnet.MNASNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.MNASNet1_3_Weights
+ :members:
+ """
+ weights = MNASNet1_3_Weights.verify(weights)
+
+ return _mnasnet(1.3, weights, progress, **kwargs)
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__init__.py b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..89d2302f825ff0dbe25d02f6dc7c84d3c0790ad0
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__init__.py
@@ -0,0 +1 @@
+from .raft import *
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__pycache__/__init__.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c753a6d13c3682acbdbb948c99627ec4856704f
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__pycache__/__init__.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__pycache__/_utils.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__pycache__/_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..dcd3799e5aec7051be821c3c7a3ac64a43d4a2f4
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__pycache__/_utils.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__pycache__/raft.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__pycache__/raft.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bc7e99b1e268a83b8736a01e14287e92236f69bd
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/__pycache__/raft.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/_utils.py b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..fa2454a27315d6e560dccb6ea2ce6083da03e256
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/_utils.py
@@ -0,0 +1,48 @@
+from typing import Optional
+
+import torch
+import torch.nn.functional as F
+from torch import Tensor
+
+
+def grid_sample(img: Tensor, absolute_grid: Tensor, mode: str = "bilinear", align_corners: Optional[bool] = None):
+ """Same as torch's grid_sample, with absolute pixel coordinates instead of normalized coordinates."""
+ h, w = img.shape[-2:]
+
+ xgrid, ygrid = absolute_grid.split([1, 1], dim=-1)
+ xgrid = 2 * xgrid / (w - 1) - 1
+ # Adding condition if h > 1 to enable this function be reused in raft-stereo
+ if h > 1:
+ ygrid = 2 * ygrid / (h - 1) - 1
+ normalized_grid = torch.cat([xgrid, ygrid], dim=-1)
+
+ return F.grid_sample(img, normalized_grid, mode=mode, align_corners=align_corners)
+
+
+def make_coords_grid(batch_size: int, h: int, w: int, device: str = "cpu"):
+ device = torch.device(device)
+ coords = torch.meshgrid(torch.arange(h, device=device), torch.arange(w, device=device), indexing="ij")
+ coords = torch.stack(coords[::-1], dim=0).float()
+ return coords[None].repeat(batch_size, 1, 1, 1)
+
+
+def upsample_flow(flow, up_mask: Optional[Tensor] = None, factor: int = 8):
+ """Upsample flow by the input factor (default 8).
+
+ If up_mask is None we just interpolate.
+ If up_mask is specified, we upsample using a convex combination of its weights. See paper page 8 and appendix B.
+ Note that in appendix B the picture assumes a downsample factor of 4 instead of 8.
+ """
+ batch_size, num_channels, h, w = flow.shape
+ new_h, new_w = h * factor, w * factor
+
+ if up_mask is None:
+ return factor * F.interpolate(flow, size=(new_h, new_w), mode="bilinear", align_corners=True)
+
+ up_mask = up_mask.view(batch_size, 1, 9, factor, factor, h, w)
+ up_mask = torch.softmax(up_mask, dim=2) # "convex" == weights sum to 1
+
+ upsampled_flow = F.unfold(factor * flow, kernel_size=3, padding=1).view(batch_size, num_channels, 9, 1, 1, h, w)
+ upsampled_flow = torch.sum(up_mask * upsampled_flow, dim=2)
+
+ return upsampled_flow.permute(0, 1, 4, 2, 5, 3).reshape(batch_size, num_channels, new_h, new_w)
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/raft.py b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/raft.py
new file mode 100644
index 0000000000000000000000000000000000000000..37da4ff0a442dd5ab4a6e7a29fe3381df2a50014
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/optical_flow/raft.py
@@ -0,0 +1,934 @@
+from typing import List, Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+from torch.nn.modules.batchnorm import BatchNorm2d
+from torch.nn.modules.instancenorm import InstanceNorm2d
+from torchvision.ops import Conv2dNormActivation
+
+from ...transforms._presets import OpticalFlow
+from ...utils import _log_api_usage_once
+from .._api import register_model, Weights, WeightsEnum
+from .._utils import handle_legacy_interface
+from ._utils import grid_sample, make_coords_grid, upsample_flow
+
+
+__all__ = (
+ "RAFT",
+ "raft_large",
+ "raft_small",
+ "Raft_Large_Weights",
+ "Raft_Small_Weights",
+)
+
+
+class ResidualBlock(nn.Module):
+ """Slightly modified Residual block with extra relu and biases."""
+
+ def __init__(self, in_channels, out_channels, *, norm_layer, stride=1, always_project: bool = False):
+ super().__init__()
+
+ # Note regarding bias=True:
+ # Usually we can pass bias=False in conv layers followed by a norm layer.
+ # But in the RAFT training reference, the BatchNorm2d layers are only activated for the first dataset,
+ # and frozen for the rest of the training process (i.e. set as eval()). The bias term is thus still useful
+ # for the rest of the datasets. Technically, we could remove the bias for other norm layers like Instance norm
+ # because these aren't frozen, but we don't bother (also, we wouldn't be able to load the original weights).
+ self.convnormrelu1 = Conv2dNormActivation(
+ in_channels, out_channels, norm_layer=norm_layer, kernel_size=3, stride=stride, bias=True
+ )
+ self.convnormrelu2 = Conv2dNormActivation(
+ out_channels, out_channels, norm_layer=norm_layer, kernel_size=3, bias=True
+ )
+
+ # make mypy happy
+ self.downsample: nn.Module
+
+ if stride == 1 and not always_project:
+ self.downsample = nn.Identity()
+ else:
+ self.downsample = Conv2dNormActivation(
+ in_channels,
+ out_channels,
+ norm_layer=norm_layer,
+ kernel_size=1,
+ stride=stride,
+ bias=True,
+ activation_layer=None,
+ )
+
+ self.relu = nn.ReLU(inplace=True)
+
+ def forward(self, x):
+ y = x
+ y = self.convnormrelu1(y)
+ y = self.convnormrelu2(y)
+
+ x = self.downsample(x)
+
+ return self.relu(x + y)
+
+
+class BottleneckBlock(nn.Module):
+ """Slightly modified BottleNeck block (extra relu and biases)"""
+
+ def __init__(self, in_channels, out_channels, *, norm_layer, stride=1):
+ super().__init__()
+
+ # See note in ResidualBlock for the reason behind bias=True
+ self.convnormrelu1 = Conv2dNormActivation(
+ in_channels, out_channels // 4, norm_layer=norm_layer, kernel_size=1, bias=True
+ )
+ self.convnormrelu2 = Conv2dNormActivation(
+ out_channels // 4, out_channels // 4, norm_layer=norm_layer, kernel_size=3, stride=stride, bias=True
+ )
+ self.convnormrelu3 = Conv2dNormActivation(
+ out_channels // 4, out_channels, norm_layer=norm_layer, kernel_size=1, bias=True
+ )
+ self.relu = nn.ReLU(inplace=True)
+
+ if stride == 1:
+ self.downsample = nn.Identity()
+ else:
+ self.downsample = Conv2dNormActivation(
+ in_channels,
+ out_channels,
+ norm_layer=norm_layer,
+ kernel_size=1,
+ stride=stride,
+ bias=True,
+ activation_layer=None,
+ )
+
+ def forward(self, x):
+ y = x
+ y = self.convnormrelu1(y)
+ y = self.convnormrelu2(y)
+ y = self.convnormrelu3(y)
+
+ x = self.downsample(x)
+
+ return self.relu(x + y)
+
+
+class FeatureEncoder(nn.Module):
+ """The feature encoder, used both as the actual feature encoder, and as the context encoder.
+
+ It must downsample its input by 8.
+ """
+
+ def __init__(
+ self, *, block=ResidualBlock, layers=(64, 64, 96, 128, 256), strides=(2, 1, 2, 2), norm_layer=nn.BatchNorm2d
+ ):
+ super().__init__()
+
+ if len(layers) != 5:
+ raise ValueError(f"The expected number of layers is 5, instead got {len(layers)}")
+
+ # See note in ResidualBlock for the reason behind bias=True
+ self.convnormrelu = Conv2dNormActivation(
+ 3, layers[0], norm_layer=norm_layer, kernel_size=7, stride=strides[0], bias=True
+ )
+
+ self.layer1 = self._make_2_blocks(block, layers[0], layers[1], norm_layer=norm_layer, first_stride=strides[1])
+ self.layer2 = self._make_2_blocks(block, layers[1], layers[2], norm_layer=norm_layer, first_stride=strides[2])
+ self.layer3 = self._make_2_blocks(block, layers[2], layers[3], norm_layer=norm_layer, first_stride=strides[3])
+
+ self.conv = nn.Conv2d(layers[3], layers[4], kernel_size=1)
+
+ for m in self.modules():
+ if isinstance(m, nn.Conv2d):
+ nn.init.kaiming_normal_(m.weight, mode="fan_out", nonlinearity="relu")
+ elif isinstance(m, (nn.BatchNorm2d, nn.InstanceNorm2d)):
+ if m.weight is not None:
+ nn.init.constant_(m.weight, 1)
+ if m.bias is not None:
+ nn.init.constant_(m.bias, 0)
+
+ num_downsamples = len(list(filter(lambda s: s == 2, strides)))
+ self.output_dim = layers[-1]
+ self.downsample_factor = 2**num_downsamples
+
+ def _make_2_blocks(self, block, in_channels, out_channels, norm_layer, first_stride):
+ block1 = block(in_channels, out_channels, norm_layer=norm_layer, stride=first_stride)
+ block2 = block(out_channels, out_channels, norm_layer=norm_layer, stride=1)
+ return nn.Sequential(block1, block2)
+
+ def forward(self, x):
+ x = self.convnormrelu(x)
+
+ x = self.layer1(x)
+ x = self.layer2(x)
+ x = self.layer3(x)
+
+ x = self.conv(x)
+
+ return x
+
+
+class MotionEncoder(nn.Module):
+ """The motion encoder, part of the update block.
+
+ Takes the current predicted flow and the correlation features as input and returns an encoded version of these.
+ """
+
+ def __init__(self, *, in_channels_corr, corr_layers=(256, 192), flow_layers=(128, 64), out_channels=128):
+ super().__init__()
+
+ if len(flow_layers) != 2:
+ raise ValueError(f"The expected number of flow_layers is 2, instead got {len(flow_layers)}")
+ if len(corr_layers) not in (1, 2):
+ raise ValueError(f"The number of corr_layers should be 1 or 2, instead got {len(corr_layers)}")
+
+ self.convcorr1 = Conv2dNormActivation(in_channels_corr, corr_layers[0], norm_layer=None, kernel_size=1)
+ if len(corr_layers) == 2:
+ self.convcorr2 = Conv2dNormActivation(corr_layers[0], corr_layers[1], norm_layer=None, kernel_size=3)
+ else:
+ self.convcorr2 = nn.Identity()
+
+ self.convflow1 = Conv2dNormActivation(2, flow_layers[0], norm_layer=None, kernel_size=7)
+ self.convflow2 = Conv2dNormActivation(flow_layers[0], flow_layers[1], norm_layer=None, kernel_size=3)
+
+ # out_channels - 2 because we cat the flow (2 channels) at the end
+ self.conv = Conv2dNormActivation(
+ corr_layers[-1] + flow_layers[-1], out_channels - 2, norm_layer=None, kernel_size=3
+ )
+
+ self.out_channels = out_channels
+
+ def forward(self, flow, corr_features):
+ corr = self.convcorr1(corr_features)
+ corr = self.convcorr2(corr)
+
+ flow_orig = flow
+ flow = self.convflow1(flow)
+ flow = self.convflow2(flow)
+
+ corr_flow = torch.cat([corr, flow], dim=1)
+ corr_flow = self.conv(corr_flow)
+ return torch.cat([corr_flow, flow_orig], dim=1)
+
+
+class ConvGRU(nn.Module):
+ """Convolutional Gru unit."""
+
+ def __init__(self, *, input_size, hidden_size, kernel_size, padding):
+ super().__init__()
+ self.convz = nn.Conv2d(hidden_size + input_size, hidden_size, kernel_size=kernel_size, padding=padding)
+ self.convr = nn.Conv2d(hidden_size + input_size, hidden_size, kernel_size=kernel_size, padding=padding)
+ self.convq = nn.Conv2d(hidden_size + input_size, hidden_size, kernel_size=kernel_size, padding=padding)
+
+ def forward(self, h, x):
+ hx = torch.cat([h, x], dim=1)
+ z = torch.sigmoid(self.convz(hx))
+ r = torch.sigmoid(self.convr(hx))
+ q = torch.tanh(self.convq(torch.cat([r * h, x], dim=1)))
+ h = (1 - z) * h + z * q
+ return h
+
+
+def _pass_through_h(h, _):
+ # Declared here for torchscript
+ return h
+
+
+class RecurrentBlock(nn.Module):
+ """Recurrent block, part of the update block.
+
+ Takes the current hidden state and the concatenation of (motion encoder output, context) as input.
+ Returns an updated hidden state.
+ """
+
+ def __init__(self, *, input_size, hidden_size, kernel_size=((1, 5), (5, 1)), padding=((0, 2), (2, 0))):
+ super().__init__()
+
+ if len(kernel_size) != len(padding):
+ raise ValueError(
+ f"kernel_size should have the same length as padding, instead got len(kernel_size) = {len(kernel_size)} and len(padding) = {len(padding)}"
+ )
+ if len(kernel_size) not in (1, 2):
+ raise ValueError(f"kernel_size should either 1 or 2, instead got {len(kernel_size)}")
+
+ self.convgru1 = ConvGRU(
+ input_size=input_size, hidden_size=hidden_size, kernel_size=kernel_size[0], padding=padding[0]
+ )
+ if len(kernel_size) == 2:
+ self.convgru2 = ConvGRU(
+ input_size=input_size, hidden_size=hidden_size, kernel_size=kernel_size[1], padding=padding[1]
+ )
+ else:
+ self.convgru2 = _pass_through_h
+
+ self.hidden_size = hidden_size
+
+ def forward(self, h, x):
+ h = self.convgru1(h, x)
+ h = self.convgru2(h, x)
+ return h
+
+
+class FlowHead(nn.Module):
+ """Flow head, part of the update block.
+
+ Takes the hidden state of the recurrent unit as input, and outputs the predicted "delta flow".
+ """
+
+ def __init__(self, *, in_channels, hidden_size):
+ super().__init__()
+ self.conv1 = nn.Conv2d(in_channels, hidden_size, 3, padding=1)
+ self.conv2 = nn.Conv2d(hidden_size, 2, 3, padding=1)
+ self.relu = nn.ReLU(inplace=True)
+
+ def forward(self, x):
+ return self.conv2(self.relu(self.conv1(x)))
+
+
+class UpdateBlock(nn.Module):
+ """The update block which contains the motion encoder, the recurrent block, and the flow head.
+
+ It must expose a ``hidden_state_size`` attribute which is the hidden state size of its recurrent block.
+ """
+
+ def __init__(self, *, motion_encoder, recurrent_block, flow_head):
+ super().__init__()
+ self.motion_encoder = motion_encoder
+ self.recurrent_block = recurrent_block
+ self.flow_head = flow_head
+
+ self.hidden_state_size = recurrent_block.hidden_size
+
+ def forward(self, hidden_state, context, corr_features, flow):
+ motion_features = self.motion_encoder(flow, corr_features)
+ x = torch.cat([context, motion_features], dim=1)
+
+ hidden_state = self.recurrent_block(hidden_state, x)
+ delta_flow = self.flow_head(hidden_state)
+ return hidden_state, delta_flow
+
+
+class MaskPredictor(nn.Module):
+ """Mask predictor to be used when upsampling the predicted flow.
+
+ It takes the hidden state of the recurrent unit as input and outputs the mask.
+ This is not used in the raft-small model.
+ """
+
+ def __init__(self, *, in_channels, hidden_size, multiplier=0.25):
+ super().__init__()
+ self.convrelu = Conv2dNormActivation(in_channels, hidden_size, norm_layer=None, kernel_size=3)
+ # 8 * 8 * 9 because the predicted flow is downsampled by 8, from the downsampling of the initial FeatureEncoder,
+ # and we interpolate with all 9 surrounding neighbors. See paper and appendix B.
+ self.conv = nn.Conv2d(hidden_size, 8 * 8 * 9, 1, padding=0)
+
+ # In the original code, they use a factor of 0.25 to "downweight the gradients" of that branch.
+ # See e.g. https://github.com/princeton-vl/RAFT/issues/119#issuecomment-953950419
+ # or https://github.com/princeton-vl/RAFT/issues/24.
+ # It doesn't seem to affect epe significantly and can likely be set to 1.
+ self.multiplier = multiplier
+
+ def forward(self, x):
+ x = self.convrelu(x)
+ x = self.conv(x)
+ return self.multiplier * x
+
+
+class CorrBlock(nn.Module):
+ """The correlation block.
+
+ Creates a correlation pyramid with ``num_levels`` levels from the outputs of the feature encoder,
+ and then indexes from this pyramid to create correlation features.
+ The "indexing" of a given centroid pixel x' is done by concatenating its surrounding neighbors that
+ are within a ``radius``, according to the infinity norm (see paper section 3.2).
+ Note: typo in the paper, it should be infinity norm, not 1-norm.
+ """
+
+ def __init__(self, *, num_levels: int = 4, radius: int = 4):
+ super().__init__()
+ self.num_levels = num_levels
+ self.radius = radius
+
+ self.corr_pyramid: List[Tensor] = [torch.tensor(0)] # useless, but torchscript is otherwise confused :')
+
+ # The neighborhood of a centroid pixel x' is {x' + delta, ||delta||_inf <= radius}
+ # so it's a square surrounding x', and its sides have a length of 2 * radius + 1
+ # The paper claims that it's ||.||_1 instead of ||.||_inf but it's a typo:
+ # https://github.com/princeton-vl/RAFT/issues/122
+ self.out_channels = num_levels * (2 * radius + 1) ** 2
+
+ def build_pyramid(self, fmap1, fmap2):
+ """Build the correlation pyramid from two feature maps.
+
+ The correlation volume is first computed as the dot product of each pair (pixel_in_fmap1, pixel_in_fmap2)
+ The last 2 dimensions of the correlation volume are then pooled num_levels times at different resolutions
+ to build the correlation pyramid.
+ """
+
+ if fmap1.shape != fmap2.shape:
+ raise ValueError(
+ f"Input feature maps should have the same shape, instead got {fmap1.shape} (fmap1.shape) != {fmap2.shape} (fmap2.shape)"
+ )
+ corr_volume = self._compute_corr_volume(fmap1, fmap2)
+
+ batch_size, h, w, num_channels, _, _ = corr_volume.shape # _, _ = h, w
+ corr_volume = corr_volume.reshape(batch_size * h * w, num_channels, h, w)
+ self.corr_pyramid = [corr_volume]
+ for _ in range(self.num_levels - 1):
+ corr_volume = F.avg_pool2d(corr_volume, kernel_size=2, stride=2)
+ self.corr_pyramid.append(corr_volume)
+
+ def index_pyramid(self, centroids_coords):
+ """Return correlation features by indexing from the pyramid."""
+ neighborhood_side_len = 2 * self.radius + 1 # see note in __init__ about out_channels
+ di = torch.linspace(-self.radius, self.radius, neighborhood_side_len)
+ dj = torch.linspace(-self.radius, self.radius, neighborhood_side_len)
+ delta = torch.stack(torch.meshgrid(di, dj, indexing="ij"), dim=-1).to(centroids_coords.device)
+ delta = delta.view(1, neighborhood_side_len, neighborhood_side_len, 2)
+
+ batch_size, _, h, w = centroids_coords.shape # _ = 2
+ centroids_coords = centroids_coords.permute(0, 2, 3, 1).reshape(batch_size * h * w, 1, 1, 2)
+
+ indexed_pyramid = []
+ for corr_volume in self.corr_pyramid:
+ sampling_coords = centroids_coords + delta # end shape is (batch_size * h * w, side_len, side_len, 2)
+ indexed_corr_volume = grid_sample(corr_volume, sampling_coords, align_corners=True, mode="bilinear").view(
+ batch_size, h, w, -1
+ )
+ indexed_pyramid.append(indexed_corr_volume)
+ centroids_coords = centroids_coords / 2
+
+ corr_features = torch.cat(indexed_pyramid, dim=-1).permute(0, 3, 1, 2).contiguous()
+
+ expected_output_shape = (batch_size, self.out_channels, h, w)
+ if corr_features.shape != expected_output_shape:
+ raise ValueError(
+ f"Output shape of index pyramid is incorrect. Should be {expected_output_shape}, got {corr_features.shape}"
+ )
+
+ return corr_features
+
+ def _compute_corr_volume(self, fmap1, fmap2):
+ batch_size, num_channels, h, w = fmap1.shape
+ fmap1 = fmap1.view(batch_size, num_channels, h * w)
+ fmap2 = fmap2.view(batch_size, num_channels, h * w)
+
+ corr = torch.matmul(fmap1.transpose(1, 2), fmap2)
+ corr = corr.view(batch_size, h, w, 1, h, w)
+ return corr / torch.sqrt(torch.tensor(num_channels))
+
+
+class RAFT(nn.Module):
+ def __init__(self, *, feature_encoder, context_encoder, corr_block, update_block, mask_predictor=None):
+ """RAFT model from
+ `RAFT: Recurrent All Pairs Field Transforms for Optical Flow `_.
+
+ args:
+ feature_encoder (nn.Module): The feature encoder. It must downsample the input by 8.
+ Its input is the concatenation of ``image1`` and ``image2``.
+ context_encoder (nn.Module): The context encoder. It must downsample the input by 8.
+ Its input is ``image1``. As in the original implementation, its output will be split into 2 parts:
+
+ - one part will be used as the actual "context", passed to the recurrent unit of the ``update_block``
+ - one part will be used to initialize the hidden state of the recurrent unit of
+ the ``update_block``
+
+ These 2 parts are split according to the ``hidden_state_size`` of the ``update_block``, so the output
+ of the ``context_encoder`` must be strictly greater than ``hidden_state_size``.
+
+ corr_block (nn.Module): The correlation block, which creates a correlation pyramid from the output of the
+ ``feature_encoder``, and then indexes from this pyramid to create correlation features. It must expose
+ 2 methods:
+
+ - a ``build_pyramid`` method that takes ``feature_map_1`` and ``feature_map_2`` as input (these are the
+ output of the ``feature_encoder``).
+ - a ``index_pyramid`` method that takes the coordinates of the centroid pixels as input, and returns
+ the correlation features. See paper section 3.2.
+
+ It must expose an ``out_channels`` attribute.
+
+ update_block (nn.Module): The update block, which contains the motion encoder, the recurrent unit, and the
+ flow head. It takes as input the hidden state of its recurrent unit, the context, the correlation
+ features, and the current predicted flow. It outputs an updated hidden state, and the ``delta_flow``
+ prediction (see paper appendix A). It must expose a ``hidden_state_size`` attribute.
+ mask_predictor (nn.Module, optional): Predicts the mask that will be used to upsample the predicted flow.
+ The output channel must be 8 * 8 * 9 - see paper section 3.3, and Appendix B.
+ If ``None`` (default), the flow is upsampled using interpolation.
+ """
+ super().__init__()
+ _log_api_usage_once(self)
+
+ self.feature_encoder = feature_encoder
+ self.context_encoder = context_encoder
+ self.corr_block = corr_block
+ self.update_block = update_block
+
+ self.mask_predictor = mask_predictor
+
+ if not hasattr(self.update_block, "hidden_state_size"):
+ raise ValueError("The update_block parameter should expose a 'hidden_state_size' attribute.")
+
+ def forward(self, image1, image2, num_flow_updates: int = 12):
+
+ batch_size, _, h, w = image1.shape
+ if (h, w) != image2.shape[-2:]:
+ raise ValueError(f"input images should have the same shape, instead got ({h}, {w}) != {image2.shape[-2:]}")
+ if not (h % 8 == 0) and (w % 8 == 0):
+ raise ValueError(f"input image H and W should be divisible by 8, instead got {h} (h) and {w} (w)")
+
+ fmaps = self.feature_encoder(torch.cat([image1, image2], dim=0))
+ fmap1, fmap2 = torch.chunk(fmaps, chunks=2, dim=0)
+ if fmap1.shape[-2:] != (h // 8, w // 8):
+ raise ValueError("The feature encoder should downsample H and W by 8")
+
+ self.corr_block.build_pyramid(fmap1, fmap2)
+
+ context_out = self.context_encoder(image1)
+ if context_out.shape[-2:] != (h // 8, w // 8):
+ raise ValueError("The context encoder should downsample H and W by 8")
+
+ # As in the original paper, the actual output of the context encoder is split in 2 parts:
+ # - one part is used to initialize the hidden state of the recurent units of the update block
+ # - the rest is the "actual" context.
+ hidden_state_size = self.update_block.hidden_state_size
+ out_channels_context = context_out.shape[1] - hidden_state_size
+ if out_channels_context <= 0:
+ raise ValueError(
+ f"The context encoder outputs {context_out.shape[1]} channels, but it should have at strictly more than hidden_state={hidden_state_size} channels"
+ )
+ hidden_state, context = torch.split(context_out, [hidden_state_size, out_channels_context], dim=1)
+ hidden_state = torch.tanh(hidden_state)
+ context = F.relu(context)
+
+ coords0 = make_coords_grid(batch_size, h // 8, w // 8).to(fmap1.device)
+ coords1 = make_coords_grid(batch_size, h // 8, w // 8).to(fmap1.device)
+
+ flow_predictions = []
+ for _ in range(num_flow_updates):
+ coords1 = coords1.detach() # Don't backpropagate gradients through this branch, see paper
+ corr_features = self.corr_block.index_pyramid(centroids_coords=coords1)
+
+ flow = coords1 - coords0
+ hidden_state, delta_flow = self.update_block(hidden_state, context, corr_features, flow)
+
+ coords1 = coords1 + delta_flow
+
+ up_mask = None if self.mask_predictor is None else self.mask_predictor(hidden_state)
+ upsampled_flow = upsample_flow(flow=(coords1 - coords0), up_mask=up_mask)
+ flow_predictions.append(upsampled_flow)
+
+ return flow_predictions
+
+
+_COMMON_META = {
+ "min_size": (128, 128),
+}
+
+
+class Raft_Large_Weights(WeightsEnum):
+ """The metrics reported here are as follows.
+
+ ``epe`` is the "end-point-error" and indicates how far (in pixels) the
+ predicted flow is from its true value. This is averaged over all pixels
+ of all images. ``per_image_epe`` is similar, but the average is different:
+ the epe is first computed on each image independently, and then averaged
+ over all images. This corresponds to "Fl-epe" (sometimes written "F1-epe")
+ in the original paper, and it's only used on Kitti. ``fl-all`` is also a
+ Kitti-specific metric, defined by the author of the dataset and used for the
+ Kitti leaderboard. It corresponds to the average of pixels whose epe is
+ either <3px, or <5% of flow's 2-norm.
+ """
+
+ C_T_V1 = Weights(
+ # Weights ported from https://github.com/princeton-vl/RAFT
+ url="https://download.pytorch.org/models/raft_large_C_T_V1-22a6c225.pth",
+ transforms=OpticalFlow,
+ meta={
+ **_COMMON_META,
+ "num_params": 5257536,
+ "recipe": "https://github.com/princeton-vl/RAFT",
+ "_metrics": {
+ "Sintel-Train-Cleanpass": {"epe": 1.4411},
+ "Sintel-Train-Finalpass": {"epe": 2.7894},
+ "Kitti-Train": {"per_image_epe": 5.0172, "fl_all": 17.4506},
+ },
+ "_ops": 211.007,
+ "_file_size": 20.129,
+ "_docs": """These weights were ported from the original paper. They
+ are trained on :class:`~torchvision.datasets.FlyingChairs` +
+ :class:`~torchvision.datasets.FlyingThings3D`.""",
+ },
+ )
+
+ C_T_V2 = Weights(
+ url="https://download.pytorch.org/models/raft_large_C_T_V2-1bb1363a.pth",
+ transforms=OpticalFlow,
+ meta={
+ **_COMMON_META,
+ "num_params": 5257536,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/optical_flow",
+ "_metrics": {
+ "Sintel-Train-Cleanpass": {"epe": 1.3822},
+ "Sintel-Train-Finalpass": {"epe": 2.7161},
+ "Kitti-Train": {"per_image_epe": 4.5118, "fl_all": 16.0679},
+ },
+ "_ops": 211.007,
+ "_file_size": 20.129,
+ "_docs": """These weights were trained from scratch on
+ :class:`~torchvision.datasets.FlyingChairs` +
+ :class:`~torchvision.datasets.FlyingThings3D`.""",
+ },
+ )
+
+ C_T_SKHT_V1 = Weights(
+ # Weights ported from https://github.com/princeton-vl/RAFT
+ url="https://download.pytorch.org/models/raft_large_C_T_SKHT_V1-0b8c9e55.pth",
+ transforms=OpticalFlow,
+ meta={
+ **_COMMON_META,
+ "num_params": 5257536,
+ "recipe": "https://github.com/princeton-vl/RAFT",
+ "_metrics": {
+ "Sintel-Test-Cleanpass": {"epe": 1.94},
+ "Sintel-Test-Finalpass": {"epe": 3.18},
+ },
+ "_ops": 211.007,
+ "_file_size": 20.129,
+ "_docs": """
+ These weights were ported from the original paper. They are
+ trained on :class:`~torchvision.datasets.FlyingChairs` +
+ :class:`~torchvision.datasets.FlyingThings3D` and fine-tuned on
+ Sintel. The Sintel fine-tuning step is a combination of
+ :class:`~torchvision.datasets.Sintel`,
+ :class:`~torchvision.datasets.KittiFlow`,
+ :class:`~torchvision.datasets.HD1K`, and
+ :class:`~torchvision.datasets.FlyingThings3D` (clean pass).
+ """,
+ },
+ )
+
+ C_T_SKHT_V2 = Weights(
+ url="https://download.pytorch.org/models/raft_large_C_T_SKHT_V2-ff5fadd5.pth",
+ transforms=OpticalFlow,
+ meta={
+ **_COMMON_META,
+ "num_params": 5257536,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/optical_flow",
+ "_metrics": {
+ "Sintel-Test-Cleanpass": {"epe": 1.819},
+ "Sintel-Test-Finalpass": {"epe": 3.067},
+ },
+ "_ops": 211.007,
+ "_file_size": 20.129,
+ "_docs": """
+ These weights were trained from scratch. They are
+ pre-trained on :class:`~torchvision.datasets.FlyingChairs` +
+ :class:`~torchvision.datasets.FlyingThings3D` and then
+ fine-tuned on Sintel. The Sintel fine-tuning step is a
+ combination of :class:`~torchvision.datasets.Sintel`,
+ :class:`~torchvision.datasets.KittiFlow`,
+ :class:`~torchvision.datasets.HD1K`, and
+ :class:`~torchvision.datasets.FlyingThings3D` (clean pass).
+ """,
+ },
+ )
+
+ C_T_SKHT_K_V1 = Weights(
+ # Weights ported from https://github.com/princeton-vl/RAFT
+ url="https://download.pytorch.org/models/raft_large_C_T_SKHT_K_V1-4a6a5039.pth",
+ transforms=OpticalFlow,
+ meta={
+ **_COMMON_META,
+ "num_params": 5257536,
+ "recipe": "https://github.com/princeton-vl/RAFT",
+ "_metrics": {
+ "Kitti-Test": {"fl_all": 5.10},
+ },
+ "_ops": 211.007,
+ "_file_size": 20.129,
+ "_docs": """
+ These weights were ported from the original paper. They are
+ pre-trained on :class:`~torchvision.datasets.FlyingChairs` +
+ :class:`~torchvision.datasets.FlyingThings3D`,
+ fine-tuned on Sintel, and then fine-tuned on
+ :class:`~torchvision.datasets.KittiFlow`. The Sintel fine-tuning
+ step was described above.
+ """,
+ },
+ )
+
+ C_T_SKHT_K_V2 = Weights(
+ url="https://download.pytorch.org/models/raft_large_C_T_SKHT_K_V2-b5c70766.pth",
+ transforms=OpticalFlow,
+ meta={
+ **_COMMON_META,
+ "num_params": 5257536,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/optical_flow",
+ "_metrics": {
+ "Kitti-Test": {"fl_all": 5.19},
+ },
+ "_ops": 211.007,
+ "_file_size": 20.129,
+ "_docs": """
+ These weights were trained from scratch. They are
+ pre-trained on :class:`~torchvision.datasets.FlyingChairs` +
+ :class:`~torchvision.datasets.FlyingThings3D`,
+ fine-tuned on Sintel, and then fine-tuned on
+ :class:`~torchvision.datasets.KittiFlow`. The Sintel fine-tuning
+ step was described above.
+ """,
+ },
+ )
+
+ DEFAULT = C_T_SKHT_V2
+
+
+class Raft_Small_Weights(WeightsEnum):
+ """The metrics reported here are as follows.
+
+ ``epe`` is the "end-point-error" and indicates how far (in pixels) the
+ predicted flow is from its true value. This is averaged over all pixels
+ of all images. ``per_image_epe`` is similar, but the average is different:
+ the epe is first computed on each image independently, and then averaged
+ over all images. This corresponds to "Fl-epe" (sometimes written "F1-epe")
+ in the original paper, and it's only used on Kitti. ``fl-all`` is also a
+ Kitti-specific metric, defined by the author of the dataset and used for the
+ Kitti leaderboard. It corresponds to the average of pixels whose epe is
+ either <3px, or <5% of flow's 2-norm.
+ """
+
+ C_T_V1 = Weights(
+ # Weights ported from https://github.com/princeton-vl/RAFT
+ url="https://download.pytorch.org/models/raft_small_C_T_V1-ad48884c.pth",
+ transforms=OpticalFlow,
+ meta={
+ **_COMMON_META,
+ "num_params": 990162,
+ "recipe": "https://github.com/princeton-vl/RAFT",
+ "_metrics": {
+ "Sintel-Train-Cleanpass": {"epe": 2.1231},
+ "Sintel-Train-Finalpass": {"epe": 3.2790},
+ "Kitti-Train": {"per_image_epe": 7.6557, "fl_all": 25.2801},
+ },
+ "_ops": 47.655,
+ "_file_size": 3.821,
+ "_docs": """These weights were ported from the original paper. They
+ are trained on :class:`~torchvision.datasets.FlyingChairs` +
+ :class:`~torchvision.datasets.FlyingThings3D`.""",
+ },
+ )
+ C_T_V2 = Weights(
+ url="https://download.pytorch.org/models/raft_small_C_T_V2-01064c6d.pth",
+ transforms=OpticalFlow,
+ meta={
+ **_COMMON_META,
+ "num_params": 990162,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/optical_flow",
+ "_metrics": {
+ "Sintel-Train-Cleanpass": {"epe": 1.9901},
+ "Sintel-Train-Finalpass": {"epe": 3.2831},
+ "Kitti-Train": {"per_image_epe": 7.5978, "fl_all": 25.2369},
+ },
+ "_ops": 47.655,
+ "_file_size": 3.821,
+ "_docs": """These weights were trained from scratch on
+ :class:`~torchvision.datasets.FlyingChairs` +
+ :class:`~torchvision.datasets.FlyingThings3D`.""",
+ },
+ )
+
+ DEFAULT = C_T_V2
+
+
+def _raft(
+ *,
+ weights=None,
+ progress=False,
+ # Feature encoder
+ feature_encoder_layers,
+ feature_encoder_block,
+ feature_encoder_norm_layer,
+ # Context encoder
+ context_encoder_layers,
+ context_encoder_block,
+ context_encoder_norm_layer,
+ # Correlation block
+ corr_block_num_levels,
+ corr_block_radius,
+ # Motion encoder
+ motion_encoder_corr_layers,
+ motion_encoder_flow_layers,
+ motion_encoder_out_channels,
+ # Recurrent block
+ recurrent_block_hidden_state_size,
+ recurrent_block_kernel_size,
+ recurrent_block_padding,
+ # Flow Head
+ flow_head_hidden_size,
+ # Mask predictor
+ use_mask_predictor,
+ **kwargs,
+):
+ feature_encoder = kwargs.pop("feature_encoder", None) or FeatureEncoder(
+ block=feature_encoder_block, layers=feature_encoder_layers, norm_layer=feature_encoder_norm_layer
+ )
+ context_encoder = kwargs.pop("context_encoder", None) or FeatureEncoder(
+ block=context_encoder_block, layers=context_encoder_layers, norm_layer=context_encoder_norm_layer
+ )
+
+ corr_block = kwargs.pop("corr_block", None) or CorrBlock(num_levels=corr_block_num_levels, radius=corr_block_radius)
+
+ update_block = kwargs.pop("update_block", None)
+ if update_block is None:
+ motion_encoder = MotionEncoder(
+ in_channels_corr=corr_block.out_channels,
+ corr_layers=motion_encoder_corr_layers,
+ flow_layers=motion_encoder_flow_layers,
+ out_channels=motion_encoder_out_channels,
+ )
+
+ # See comments in forward pass of RAFT class about why we split the output of the context encoder
+ out_channels_context = context_encoder_layers[-1] - recurrent_block_hidden_state_size
+ recurrent_block = RecurrentBlock(
+ input_size=motion_encoder.out_channels + out_channels_context,
+ hidden_size=recurrent_block_hidden_state_size,
+ kernel_size=recurrent_block_kernel_size,
+ padding=recurrent_block_padding,
+ )
+
+ flow_head = FlowHead(in_channels=recurrent_block_hidden_state_size, hidden_size=flow_head_hidden_size)
+
+ update_block = UpdateBlock(motion_encoder=motion_encoder, recurrent_block=recurrent_block, flow_head=flow_head)
+
+ mask_predictor = kwargs.pop("mask_predictor", None)
+ if mask_predictor is None and use_mask_predictor:
+ mask_predictor = MaskPredictor(
+ in_channels=recurrent_block_hidden_state_size,
+ hidden_size=256,
+ multiplier=0.25, # See comment in MaskPredictor about this
+ )
+
+ model = RAFT(
+ feature_encoder=feature_encoder,
+ context_encoder=context_encoder,
+ corr_block=corr_block,
+ update_block=update_block,
+ mask_predictor=mask_predictor,
+ **kwargs, # not really needed, all params should be consumed by now
+ )
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", Raft_Large_Weights.C_T_SKHT_V2))
+def raft_large(*, weights: Optional[Raft_Large_Weights] = None, progress=True, **kwargs) -> RAFT:
+ """RAFT model from
+ `RAFT: Recurrent All Pairs Field Transforms for Optical Flow `_.
+
+ Please see the example below for a tutorial on how to use this model.
+
+ Args:
+ weights(:class:`~torchvision.models.optical_flow.Raft_Large_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.optical_flow.Raft_Large_Weights`
+ below for more details, and possible values. By default, no
+ pre-trained weights are used.
+ progress (bool): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.optical_flow.RAFT``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.optical_flow.Raft_Large_Weights
+ :members:
+ """
+
+ weights = Raft_Large_Weights.verify(weights)
+
+ return _raft(
+ weights=weights,
+ progress=progress,
+ # Feature encoder
+ feature_encoder_layers=(64, 64, 96, 128, 256),
+ feature_encoder_block=ResidualBlock,
+ feature_encoder_norm_layer=InstanceNorm2d,
+ # Context encoder
+ context_encoder_layers=(64, 64, 96, 128, 256),
+ context_encoder_block=ResidualBlock,
+ context_encoder_norm_layer=BatchNorm2d,
+ # Correlation block
+ corr_block_num_levels=4,
+ corr_block_radius=4,
+ # Motion encoder
+ motion_encoder_corr_layers=(256, 192),
+ motion_encoder_flow_layers=(128, 64),
+ motion_encoder_out_channels=128,
+ # Recurrent block
+ recurrent_block_hidden_state_size=128,
+ recurrent_block_kernel_size=((1, 5), (5, 1)),
+ recurrent_block_padding=((0, 2), (2, 0)),
+ # Flow head
+ flow_head_hidden_size=256,
+ # Mask predictor
+ use_mask_predictor=True,
+ **kwargs,
+ )
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", Raft_Small_Weights.C_T_V2))
+def raft_small(*, weights: Optional[Raft_Small_Weights] = None, progress=True, **kwargs) -> RAFT:
+ """RAFT "small" model from
+ `RAFT: Recurrent All Pairs Field Transforms for Optical Flow `__.
+
+ Please see the example below for a tutorial on how to use this model.
+
+ Args:
+ weights(:class:`~torchvision.models.optical_flow.Raft_Small_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.optical_flow.Raft_Small_Weights`
+ below for more details, and possible values. By default, no
+ pre-trained weights are used.
+ progress (bool): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.optical_flow.RAFT``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.optical_flow.Raft_Small_Weights
+ :members:
+ """
+ weights = Raft_Small_Weights.verify(weights)
+
+ return _raft(
+ weights=weights,
+ progress=progress,
+ # Feature encoder
+ feature_encoder_layers=(32, 32, 64, 96, 128),
+ feature_encoder_block=BottleneckBlock,
+ feature_encoder_norm_layer=InstanceNorm2d,
+ # Context encoder
+ context_encoder_layers=(32, 32, 64, 96, 160),
+ context_encoder_block=BottleneckBlock,
+ context_encoder_norm_layer=None,
+ # Correlation block
+ corr_block_num_levels=4,
+ corr_block_radius=3,
+ # Motion encoder
+ motion_encoder_corr_layers=(96,),
+ motion_encoder_flow_layers=(64, 32),
+ motion_encoder_out_channels=82,
+ # Recurrent block
+ recurrent_block_hidden_state_size=96,
+ recurrent_block_kernel_size=(3,),
+ recurrent_block_padding=(1,),
+ # Flow head
+ flow_head_hidden_size=128,
+ # Mask predictor
+ use_mask_predictor=False,
+ **kwargs,
+ )
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__init__.py b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..da8bbba3567b0b9110429354d89b65ec679a2fd5
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__init__.py
@@ -0,0 +1,5 @@
+from .googlenet import *
+from .inception import *
+from .mobilenet import *
+from .resnet import *
+from .shufflenetv2 import *
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/__init__.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a6398c6298da646ee1f46e017bc9b96674ea7e0
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/__init__.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/googlenet.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/googlenet.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b5209c92d7b7a6be39bd54e270661bb02b38a018
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/googlenet.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/mobilenet.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/mobilenet.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3c5c759c4b91028aa66f41e08e48aee16cb47cbb
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/mobilenet.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/mobilenetv2.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/mobilenetv2.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5dc93e7097c0b0d4007514305de58528cda6d93a
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/mobilenetv2.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/mobilenetv3.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/mobilenetv3.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..61109487e3141f9bd0ac29ebbf1953c96b468b37
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/mobilenetv3.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/resnet.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/resnet.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..7fb1d0a21608745cb0b06aa408467b4d3116e966
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/resnet.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/utils.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..4272603f78440561cacb86254943b07bc5d9457a
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/__pycache__/utils.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/quantization/googlenet.py b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/googlenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..6998a2b5389c5f257dc47d6c91096545d374604d
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/googlenet.py
@@ -0,0 +1,210 @@
+import warnings
+from functools import partial
+from typing import Any, Optional, Union
+
+import torch
+import torch.nn as nn
+from torch import Tensor
+from torch.nn import functional as F
+
+from ...transforms._presets import ImageClassification
+from .._api import register_model, Weights, WeightsEnum
+from .._meta import _IMAGENET_CATEGORIES
+from .._utils import _ovewrite_named_param, handle_legacy_interface
+from ..googlenet import BasicConv2d, GoogLeNet, GoogLeNet_Weights, GoogLeNetOutputs, Inception, InceptionAux
+from .utils import _fuse_modules, _replace_relu, quantize_model
+
+
+__all__ = [
+ "QuantizableGoogLeNet",
+ "GoogLeNet_QuantizedWeights",
+ "googlenet",
+]
+
+
+class QuantizableBasicConv2d(BasicConv2d):
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__(*args, **kwargs)
+ self.relu = nn.ReLU()
+
+ def forward(self, x: Tensor) -> Tensor:
+ x = self.conv(x)
+ x = self.bn(x)
+ x = self.relu(x)
+ return x
+
+ def fuse_model(self, is_qat: Optional[bool] = None) -> None:
+ _fuse_modules(self, ["conv", "bn", "relu"], is_qat, inplace=True)
+
+
+class QuantizableInception(Inception):
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__(*args, conv_block=QuantizableBasicConv2d, **kwargs) # type: ignore[misc]
+ self.cat = nn.quantized.FloatFunctional()
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return self.cat.cat(outputs, 1)
+
+
+class QuantizableInceptionAux(InceptionAux):
+ # TODO https://github.com/pytorch/vision/pull/4232#pullrequestreview-730461659
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__(*args, conv_block=QuantizableBasicConv2d, **kwargs) # type: ignore[misc]
+ self.relu = nn.ReLU()
+
+ def forward(self, x: Tensor) -> Tensor:
+ # aux1: N x 512 x 14 x 14, aux2: N x 528 x 14 x 14
+ x = F.adaptive_avg_pool2d(x, (4, 4))
+ # aux1: N x 512 x 4 x 4, aux2: N x 528 x 4 x 4
+ x = self.conv(x)
+ # N x 128 x 4 x 4
+ x = torch.flatten(x, 1)
+ # N x 2048
+ x = self.relu(self.fc1(x))
+ # N x 1024
+ x = self.dropout(x)
+ # N x 1024
+ x = self.fc2(x)
+ # N x 1000 (num_classes)
+
+ return x
+
+
+class QuantizableGoogLeNet(GoogLeNet):
+ # TODO https://github.com/pytorch/vision/pull/4232#pullrequestreview-730461659
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__( # type: ignore[misc]
+ *args, blocks=[QuantizableBasicConv2d, QuantizableInception, QuantizableInceptionAux], **kwargs
+ )
+ self.quant = torch.ao.quantization.QuantStub()
+ self.dequant = torch.ao.quantization.DeQuantStub()
+
+ def forward(self, x: Tensor) -> GoogLeNetOutputs:
+ x = self._transform_input(x)
+ x = self.quant(x)
+ x, aux1, aux2 = self._forward(x)
+ x = self.dequant(x)
+ aux_defined = self.training and self.aux_logits
+ if torch.jit.is_scripting():
+ if not aux_defined:
+ warnings.warn("Scripted QuantizableGoogleNet always returns GoogleNetOutputs Tuple")
+ return GoogLeNetOutputs(x, aux2, aux1)
+ else:
+ return self.eager_outputs(x, aux2, aux1)
+
+ def fuse_model(self, is_qat: Optional[bool] = None) -> None:
+ r"""Fuse conv/bn/relu modules in googlenet model
+
+ Fuse conv+bn+relu/ conv+relu/conv+bn modules to prepare for quantization.
+ Model is modified in place. Note that this operation does not change numerics
+ and the model after modification is in floating point
+ """
+
+ for m in self.modules():
+ if type(m) is QuantizableBasicConv2d:
+ m.fuse_model(is_qat)
+
+
+class GoogLeNet_QuantizedWeights(WeightsEnum):
+ IMAGENET1K_FBGEMM_V1 = Weights(
+ url="https://download.pytorch.org/models/quantized/googlenet_fbgemm-c00238cf.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ "num_params": 6624904,
+ "min_size": (15, 15),
+ "categories": _IMAGENET_CATEGORIES,
+ "backend": "fbgemm",
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#post-training-quantized-models",
+ "unquantized": GoogLeNet_Weights.IMAGENET1K_V1,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 69.826,
+ "acc@5": 89.404,
+ }
+ },
+ "_ops": 1.498,
+ "_file_size": 12.618,
+ "_docs": """
+ These weights were produced by doing Post Training Quantization (eager mode) on top of the unquantized
+ weights listed below.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_FBGEMM_V1
+
+
+@register_model(name="quantized_googlenet")
+@handle_legacy_interface(
+ weights=(
+ "pretrained",
+ lambda kwargs: GoogLeNet_QuantizedWeights.IMAGENET1K_FBGEMM_V1
+ if kwargs.get("quantize", False)
+ else GoogLeNet_Weights.IMAGENET1K_V1,
+ )
+)
+def googlenet(
+ *,
+ weights: Optional[Union[GoogLeNet_QuantizedWeights, GoogLeNet_Weights]] = None,
+ progress: bool = True,
+ quantize: bool = False,
+ **kwargs: Any,
+) -> QuantizableGoogLeNet:
+ """GoogLeNet (Inception v1) model architecture from `Going Deeper with Convolutions `__.
+
+ .. note::
+ Note that ``quantize = True`` returns a quantized model with 8 bit
+ weights. Quantized models only support inference and run on CPUs.
+ GPU inference is not yet supported.
+
+ Args:
+ weights (:class:`~torchvision.models.quantization.GoogLeNet_QuantizedWeights` or :class:`~torchvision.models.GoogLeNet_Weights`, optional): The
+ pretrained weights for the model. See
+ :class:`~torchvision.models.quantization.GoogLeNet_QuantizedWeights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ quantize (bool, optional): If True, return a quantized version of the model. Default is False.
+ **kwargs: parameters passed to the ``torchvision.models.quantization.QuantizableGoogLeNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.quantization.GoogLeNet_QuantizedWeights
+ :members:
+
+ .. autoclass:: torchvision.models.GoogLeNet_Weights
+ :members:
+ :noindex:
+ """
+ weights = (GoogLeNet_QuantizedWeights if quantize else GoogLeNet_Weights).verify(weights)
+
+ original_aux_logits = kwargs.get("aux_logits", False)
+ if weights is not None:
+ if "transform_input" not in kwargs:
+ _ovewrite_named_param(kwargs, "transform_input", True)
+ _ovewrite_named_param(kwargs, "aux_logits", True)
+ _ovewrite_named_param(kwargs, "init_weights", False)
+ _ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"]))
+ if "backend" in weights.meta:
+ _ovewrite_named_param(kwargs, "backend", weights.meta["backend"])
+ backend = kwargs.pop("backend", "fbgemm")
+
+ model = QuantizableGoogLeNet(**kwargs)
+ _replace_relu(model)
+ if quantize:
+ quantize_model(model, backend)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+ if not original_aux_logits:
+ model.aux_logits = False
+ model.aux1 = None # type: ignore[assignment]
+ model.aux2 = None # type: ignore[assignment]
+ else:
+ warnings.warn(
+ "auxiliary heads in the pretrained googlenet model are NOT pretrained, so make sure to train them"
+ )
+
+ return model
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/quantization/inception.py b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/inception.py
new file mode 100644
index 0000000000000000000000000000000000000000..3421095d780d193896c4ecded99abc4ac5ac5992
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/quantization/inception.py
@@ -0,0 +1,273 @@
+import warnings
+from functools import partial
+from typing import Any, List, Optional, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch import Tensor
+from torchvision.models import inception as inception_module
+from torchvision.models.inception import Inception_V3_Weights, InceptionOutputs
+
+from ...transforms._presets import ImageClassification
+from .._api import register_model, Weights, WeightsEnum
+from .._meta import _IMAGENET_CATEGORIES
+from .._utils import _ovewrite_named_param, handle_legacy_interface
+from .utils import _fuse_modules, _replace_relu, quantize_model
+
+
+__all__ = [
+ "QuantizableInception3",
+ "Inception_V3_QuantizedWeights",
+ "inception_v3",
+]
+
+
+class QuantizableBasicConv2d(inception_module.BasicConv2d):
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__(*args, **kwargs)
+ self.relu = nn.ReLU()
+
+ def forward(self, x: Tensor) -> Tensor:
+ x = self.conv(x)
+ x = self.bn(x)
+ x = self.relu(x)
+ return x
+
+ def fuse_model(self, is_qat: Optional[bool] = None) -> None:
+ _fuse_modules(self, ["conv", "bn", "relu"], is_qat, inplace=True)
+
+
+class QuantizableInceptionA(inception_module.InceptionA):
+ # TODO https://github.com/pytorch/vision/pull/4232#pullrequestreview-730461659
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__(*args, conv_block=QuantizableBasicConv2d, **kwargs) # type: ignore[misc]
+ self.myop = nn.quantized.FloatFunctional()
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return self.myop.cat(outputs, 1)
+
+
+class QuantizableInceptionB(inception_module.InceptionB):
+ # TODO https://github.com/pytorch/vision/pull/4232#pullrequestreview-730461659
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__(*args, conv_block=QuantizableBasicConv2d, **kwargs) # type: ignore[misc]
+ self.myop = nn.quantized.FloatFunctional()
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return self.myop.cat(outputs, 1)
+
+
+class QuantizableInceptionC(inception_module.InceptionC):
+ # TODO https://github.com/pytorch/vision/pull/4232#pullrequestreview-730461659
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__(*args, conv_block=QuantizableBasicConv2d, **kwargs) # type: ignore[misc]
+ self.myop = nn.quantized.FloatFunctional()
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return self.myop.cat(outputs, 1)
+
+
+class QuantizableInceptionD(inception_module.InceptionD):
+ # TODO https://github.com/pytorch/vision/pull/4232#pullrequestreview-730461659
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__(*args, conv_block=QuantizableBasicConv2d, **kwargs) # type: ignore[misc]
+ self.myop = nn.quantized.FloatFunctional()
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return self.myop.cat(outputs, 1)
+
+
+class QuantizableInceptionE(inception_module.InceptionE):
+ # TODO https://github.com/pytorch/vision/pull/4232#pullrequestreview-730461659
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__(*args, conv_block=QuantizableBasicConv2d, **kwargs) # type: ignore[misc]
+ self.myop1 = nn.quantized.FloatFunctional()
+ self.myop2 = nn.quantized.FloatFunctional()
+ self.myop3 = nn.quantized.FloatFunctional()
+
+ def _forward(self, x: Tensor) -> List[Tensor]:
+ branch1x1 = self.branch1x1(x)
+
+ branch3x3 = self.branch3x3_1(x)
+ branch3x3 = [self.branch3x3_2a(branch3x3), self.branch3x3_2b(branch3x3)]
+ branch3x3 = self.myop1.cat(branch3x3, 1)
+
+ branch3x3dbl = self.branch3x3dbl_1(x)
+ branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
+ branch3x3dbl = [
+ self.branch3x3dbl_3a(branch3x3dbl),
+ self.branch3x3dbl_3b(branch3x3dbl),
+ ]
+ branch3x3dbl = self.myop2.cat(branch3x3dbl, 1)
+
+ branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
+ branch_pool = self.branch_pool(branch_pool)
+
+ outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool]
+ return outputs
+
+ def forward(self, x: Tensor) -> Tensor:
+ outputs = self._forward(x)
+ return self.myop3.cat(outputs, 1)
+
+
+class QuantizableInceptionAux(inception_module.InceptionAux):
+ # TODO https://github.com/pytorch/vision/pull/4232#pullrequestreview-730461659
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__(*args, conv_block=QuantizableBasicConv2d, **kwargs) # type: ignore[misc]
+
+
+class QuantizableInception3(inception_module.Inception3):
+ def __init__(self, *args: Any, **kwargs: Any) -> None:
+ super().__init__( # type: ignore[misc]
+ *args,
+ inception_blocks=[
+ QuantizableBasicConv2d,
+ QuantizableInceptionA,
+ QuantizableInceptionB,
+ QuantizableInceptionC,
+ QuantizableInceptionD,
+ QuantizableInceptionE,
+ QuantizableInceptionAux,
+ ],
+ **kwargs,
+ )
+ self.quant = torch.ao.quantization.QuantStub()
+ self.dequant = torch.ao.quantization.DeQuantStub()
+
+ def forward(self, x: Tensor) -> InceptionOutputs:
+ x = self._transform_input(x)
+ x = self.quant(x)
+ x, aux = self._forward(x)
+ x = self.dequant(x)
+ aux_defined = self.training and self.aux_logits
+ if torch.jit.is_scripting():
+ if not aux_defined:
+ warnings.warn("Scripted QuantizableInception3 always returns QuantizableInception3 Tuple")
+ return InceptionOutputs(x, aux)
+ else:
+ return self.eager_outputs(x, aux)
+
+ def fuse_model(self, is_qat: Optional[bool] = None) -> None:
+ r"""Fuse conv/bn/relu modules in inception model
+
+ Fuse conv+bn+relu/ conv+relu/conv+bn modules to prepare for quantization.
+ Model is modified in place. Note that this operation does not change numerics
+ and the model after modification is in floating point
+ """
+
+ for m in self.modules():
+ if type(m) is QuantizableBasicConv2d:
+ m.fuse_model(is_qat)
+
+
+class Inception_V3_QuantizedWeights(WeightsEnum):
+ IMAGENET1K_FBGEMM_V1 = Weights(
+ url="https://download.pytorch.org/models/quantized/inception_v3_google_fbgemm-71447a44.pth",
+ transforms=partial(ImageClassification, crop_size=299, resize_size=342),
+ meta={
+ "num_params": 27161264,
+ "min_size": (75, 75),
+ "categories": _IMAGENET_CATEGORIES,
+ "backend": "fbgemm",
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#post-training-quantized-models",
+ "unquantized": Inception_V3_Weights.IMAGENET1K_V1,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 77.176,
+ "acc@5": 93.354,
+ }
+ },
+ "_ops": 5.713,
+ "_file_size": 23.146,
+ "_docs": """
+ These weights were produced by doing Post Training Quantization (eager mode) on top of the unquantized
+ weights listed below.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_FBGEMM_V1
+
+
+@register_model(name="quantized_inception_v3")
+@handle_legacy_interface(
+ weights=(
+ "pretrained",
+ lambda kwargs: Inception_V3_QuantizedWeights.IMAGENET1K_FBGEMM_V1
+ if kwargs.get("quantize", False)
+ else Inception_V3_Weights.IMAGENET1K_V1,
+ )
+)
+def inception_v3(
+ *,
+ weights: Optional[Union[Inception_V3_QuantizedWeights, Inception_V3_Weights]] = None,
+ progress: bool = True,
+ quantize: bool = False,
+ **kwargs: Any,
+) -> QuantizableInception3:
+ r"""Inception v3 model architecture from
+ `Rethinking the Inception Architecture for Computer Vision `__.
+
+ .. note::
+ **Important**: In contrast to the other models the inception_v3 expects tensors with a size of
+ N x 3 x 299 x 299, so ensure your images are sized accordingly.
+
+ .. note::
+ Note that ``quantize = True`` returns a quantized model with 8 bit
+ weights. Quantized models only support inference and run on CPUs.
+ GPU inference is not yet supported.
+
+ Args:
+ weights (:class:`~torchvision.models.quantization.Inception_V3_QuantizedWeights` or :class:`~torchvision.models.Inception_V3_Weights`, optional): The pretrained
+ weights for the model. See
+ :class:`~torchvision.models.quantization.Inception_V3_QuantizedWeights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr.
+ Default is True.
+ quantize (bool, optional): If True, return a quantized version of the model.
+ Default is False.
+ **kwargs: parameters passed to the ``torchvision.models.quantization.QuantizableInception3``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.quantization.Inception_V3_QuantizedWeights
+ :members:
+
+ .. autoclass:: torchvision.models.Inception_V3_Weights
+ :members:
+ :noindex:
+ """
+ weights = (Inception_V3_QuantizedWeights if quantize else Inception_V3_Weights).verify(weights)
+
+ original_aux_logits = kwargs.get("aux_logits", False)
+ if weights is not None:
+ if "transform_input" not in kwargs:
+ _ovewrite_named_param(kwargs, "transform_input", True)
+ _ovewrite_named_param(kwargs, "aux_logits", True)
+ _ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"]))
+ if "backend" in weights.meta:
+ _ovewrite_named_param(kwargs, "backend", weights.meta["backend"])
+ backend = kwargs.pop("backend", "fbgemm")
+
+ model = QuantizableInception3(**kwargs)
+ _replace_relu(model)
+ if quantize:
+ quantize_model(model, backend)
+
+ if weights is not None:
+ if quantize and not original_aux_logits:
+ model.aux_logits = False
+ model.AuxLogits = None
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+ if not quantize and not original_aux_logits:
+ model.aux_logits = False
+ model.AuxLogits = None
+
+ return model
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/regnet.py b/wemm/lib/python3.10/site-packages/torchvision/models/regnet.py
new file mode 100644
index 0000000000000000000000000000000000000000..e887640e872051cfcea286976c37f635f0f22296
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/regnet.py
@@ -0,0 +1,1571 @@
+import math
+from collections import OrderedDict
+from functools import partial
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+import torch
+from torch import nn, Tensor
+
+from ..ops.misc import Conv2dNormActivation, SqueezeExcitation
+from ..transforms._presets import ImageClassification, InterpolationMode
+from ..utils import _log_api_usage_once
+from ._api import register_model, Weights, WeightsEnum
+from ._meta import _IMAGENET_CATEGORIES
+from ._utils import _make_divisible, _ovewrite_named_param, handle_legacy_interface
+
+
+__all__ = [
+ "RegNet",
+ "RegNet_Y_400MF_Weights",
+ "RegNet_Y_800MF_Weights",
+ "RegNet_Y_1_6GF_Weights",
+ "RegNet_Y_3_2GF_Weights",
+ "RegNet_Y_8GF_Weights",
+ "RegNet_Y_16GF_Weights",
+ "RegNet_Y_32GF_Weights",
+ "RegNet_Y_128GF_Weights",
+ "RegNet_X_400MF_Weights",
+ "RegNet_X_800MF_Weights",
+ "RegNet_X_1_6GF_Weights",
+ "RegNet_X_3_2GF_Weights",
+ "RegNet_X_8GF_Weights",
+ "RegNet_X_16GF_Weights",
+ "RegNet_X_32GF_Weights",
+ "regnet_y_400mf",
+ "regnet_y_800mf",
+ "regnet_y_1_6gf",
+ "regnet_y_3_2gf",
+ "regnet_y_8gf",
+ "regnet_y_16gf",
+ "regnet_y_32gf",
+ "regnet_y_128gf",
+ "regnet_x_400mf",
+ "regnet_x_800mf",
+ "regnet_x_1_6gf",
+ "regnet_x_3_2gf",
+ "regnet_x_8gf",
+ "regnet_x_16gf",
+ "regnet_x_32gf",
+]
+
+
+class SimpleStemIN(Conv2dNormActivation):
+ """Simple stem for ImageNet: 3x3, BN, ReLU."""
+
+ def __init__(
+ self,
+ width_in: int,
+ width_out: int,
+ norm_layer: Callable[..., nn.Module],
+ activation_layer: Callable[..., nn.Module],
+ ) -> None:
+ super().__init__(
+ width_in, width_out, kernel_size=3, stride=2, norm_layer=norm_layer, activation_layer=activation_layer
+ )
+
+
+class BottleneckTransform(nn.Sequential):
+ """Bottleneck transformation: 1x1, 3x3 [+SE], 1x1."""
+
+ def __init__(
+ self,
+ width_in: int,
+ width_out: int,
+ stride: int,
+ norm_layer: Callable[..., nn.Module],
+ activation_layer: Callable[..., nn.Module],
+ group_width: int,
+ bottleneck_multiplier: float,
+ se_ratio: Optional[float],
+ ) -> None:
+ layers: OrderedDict[str, nn.Module] = OrderedDict()
+ w_b = int(round(width_out * bottleneck_multiplier))
+ g = w_b // group_width
+
+ layers["a"] = Conv2dNormActivation(
+ width_in, w_b, kernel_size=1, stride=1, norm_layer=norm_layer, activation_layer=activation_layer
+ )
+ layers["b"] = Conv2dNormActivation(
+ w_b, w_b, kernel_size=3, stride=stride, groups=g, norm_layer=norm_layer, activation_layer=activation_layer
+ )
+
+ if se_ratio:
+ # The SE reduction ratio is defined with respect to the
+ # beginning of the block
+ width_se_out = int(round(se_ratio * width_in))
+ layers["se"] = SqueezeExcitation(
+ input_channels=w_b,
+ squeeze_channels=width_se_out,
+ activation=activation_layer,
+ )
+
+ layers["c"] = Conv2dNormActivation(
+ w_b, width_out, kernel_size=1, stride=1, norm_layer=norm_layer, activation_layer=None
+ )
+ super().__init__(layers)
+
+
+class ResBottleneckBlock(nn.Module):
+ """Residual bottleneck block: x + F(x), F = bottleneck transform."""
+
+ def __init__(
+ self,
+ width_in: int,
+ width_out: int,
+ stride: int,
+ norm_layer: Callable[..., nn.Module],
+ activation_layer: Callable[..., nn.Module],
+ group_width: int = 1,
+ bottleneck_multiplier: float = 1.0,
+ se_ratio: Optional[float] = None,
+ ) -> None:
+ super().__init__()
+
+ # Use skip connection with projection if shape changes
+ self.proj = None
+ should_proj = (width_in != width_out) or (stride != 1)
+ if should_proj:
+ self.proj = Conv2dNormActivation(
+ width_in, width_out, kernel_size=1, stride=stride, norm_layer=norm_layer, activation_layer=None
+ )
+ self.f = BottleneckTransform(
+ width_in,
+ width_out,
+ stride,
+ norm_layer,
+ activation_layer,
+ group_width,
+ bottleneck_multiplier,
+ se_ratio,
+ )
+ self.activation = activation_layer(inplace=True)
+
+ def forward(self, x: Tensor) -> Tensor:
+ if self.proj is not None:
+ x = self.proj(x) + self.f(x)
+ else:
+ x = x + self.f(x)
+ return self.activation(x)
+
+
+class AnyStage(nn.Sequential):
+ """AnyNet stage (sequence of blocks w/ the same output shape)."""
+
+ def __init__(
+ self,
+ width_in: int,
+ width_out: int,
+ stride: int,
+ depth: int,
+ block_constructor: Callable[..., nn.Module],
+ norm_layer: Callable[..., nn.Module],
+ activation_layer: Callable[..., nn.Module],
+ group_width: int,
+ bottleneck_multiplier: float,
+ se_ratio: Optional[float] = None,
+ stage_index: int = 0,
+ ) -> None:
+ super().__init__()
+
+ for i in range(depth):
+ block = block_constructor(
+ width_in if i == 0 else width_out,
+ width_out,
+ stride if i == 0 else 1,
+ norm_layer,
+ activation_layer,
+ group_width,
+ bottleneck_multiplier,
+ se_ratio,
+ )
+
+ self.add_module(f"block{stage_index}-{i}", block)
+
+
+class BlockParams:
+ def __init__(
+ self,
+ depths: List[int],
+ widths: List[int],
+ group_widths: List[int],
+ bottleneck_multipliers: List[float],
+ strides: List[int],
+ se_ratio: Optional[float] = None,
+ ) -> None:
+ self.depths = depths
+ self.widths = widths
+ self.group_widths = group_widths
+ self.bottleneck_multipliers = bottleneck_multipliers
+ self.strides = strides
+ self.se_ratio = se_ratio
+
+ @classmethod
+ def from_init_params(
+ cls,
+ depth: int,
+ w_0: int,
+ w_a: float,
+ w_m: float,
+ group_width: int,
+ bottleneck_multiplier: float = 1.0,
+ se_ratio: Optional[float] = None,
+ **kwargs: Any,
+ ) -> "BlockParams":
+ """
+ Programmatically compute all the per-block settings,
+ given the RegNet parameters.
+
+ The first step is to compute the quantized linear block parameters,
+ in log space. Key parameters are:
+ - `w_a` is the width progression slope
+ - `w_0` is the initial width
+ - `w_m` is the width stepping in the log space
+
+ In other terms
+ `log(block_width) = log(w_0) + w_m * block_capacity`,
+ with `bock_capacity` ramping up following the w_0 and w_a params.
+ This block width is finally quantized to multiples of 8.
+
+ The second step is to compute the parameters per stage,
+ taking into account the skip connection and the final 1x1 convolutions.
+ We use the fact that the output width is constant within a stage.
+ """
+
+ QUANT = 8
+ STRIDE = 2
+
+ if w_a < 0 or w_0 <= 0 or w_m <= 1 or w_0 % 8 != 0:
+ raise ValueError("Invalid RegNet settings")
+ # Compute the block widths. Each stage has one unique block width
+ widths_cont = torch.arange(depth) * w_a + w_0
+ block_capacity = torch.round(torch.log(widths_cont / w_0) / math.log(w_m))
+ block_widths = (torch.round(torch.divide(w_0 * torch.pow(w_m, block_capacity), QUANT)) * QUANT).int().tolist()
+ num_stages = len(set(block_widths))
+
+ # Convert to per stage parameters
+ split_helper = zip(
+ block_widths + [0],
+ [0] + block_widths,
+ block_widths + [0],
+ [0] + block_widths,
+ )
+ splits = [w != wp or r != rp for w, wp, r, rp in split_helper]
+
+ stage_widths = [w for w, t in zip(block_widths, splits[:-1]) if t]
+ stage_depths = torch.diff(torch.tensor([d for d, t in enumerate(splits) if t])).int().tolist()
+
+ strides = [STRIDE] * num_stages
+ bottleneck_multipliers = [bottleneck_multiplier] * num_stages
+ group_widths = [group_width] * num_stages
+
+ # Adjust the compatibility of stage widths and group widths
+ stage_widths, group_widths = cls._adjust_widths_groups_compatibilty(
+ stage_widths, bottleneck_multipliers, group_widths
+ )
+
+ return cls(
+ depths=stage_depths,
+ widths=stage_widths,
+ group_widths=group_widths,
+ bottleneck_multipliers=bottleneck_multipliers,
+ strides=strides,
+ se_ratio=se_ratio,
+ )
+
+ def _get_expanded_params(self):
+ return zip(self.widths, self.strides, self.depths, self.group_widths, self.bottleneck_multipliers)
+
+ @staticmethod
+ def _adjust_widths_groups_compatibilty(
+ stage_widths: List[int], bottleneck_ratios: List[float], group_widths: List[int]
+ ) -> Tuple[List[int], List[int]]:
+ """
+ Adjusts the compatibility of widths and groups,
+ depending on the bottleneck ratio.
+ """
+ # Compute all widths for the current settings
+ widths = [int(w * b) for w, b in zip(stage_widths, bottleneck_ratios)]
+ group_widths_min = [min(g, w_bot) for g, w_bot in zip(group_widths, widths)]
+
+ # Compute the adjusted widths so that stage and group widths fit
+ ws_bot = [_make_divisible(w_bot, g) for w_bot, g in zip(widths, group_widths_min)]
+ stage_widths = [int(w_bot / b) for w_bot, b in zip(ws_bot, bottleneck_ratios)]
+ return stage_widths, group_widths_min
+
+
+class RegNet(nn.Module):
+ def __init__(
+ self,
+ block_params: BlockParams,
+ num_classes: int = 1000,
+ stem_width: int = 32,
+ stem_type: Optional[Callable[..., nn.Module]] = None,
+ block_type: Optional[Callable[..., nn.Module]] = None,
+ norm_layer: Optional[Callable[..., nn.Module]] = None,
+ activation: Optional[Callable[..., nn.Module]] = None,
+ ) -> None:
+ super().__init__()
+ _log_api_usage_once(self)
+
+ if stem_type is None:
+ stem_type = SimpleStemIN
+ if norm_layer is None:
+ norm_layer = nn.BatchNorm2d
+ if block_type is None:
+ block_type = ResBottleneckBlock
+ if activation is None:
+ activation = nn.ReLU
+
+ # Ad hoc stem
+ self.stem = stem_type(
+ 3, # width_in
+ stem_width,
+ norm_layer,
+ activation,
+ )
+
+ current_width = stem_width
+
+ blocks = []
+ for i, (
+ width_out,
+ stride,
+ depth,
+ group_width,
+ bottleneck_multiplier,
+ ) in enumerate(block_params._get_expanded_params()):
+ blocks.append(
+ (
+ f"block{i+1}",
+ AnyStage(
+ current_width,
+ width_out,
+ stride,
+ depth,
+ block_type,
+ norm_layer,
+ activation,
+ group_width,
+ bottleneck_multiplier,
+ block_params.se_ratio,
+ stage_index=i + 1,
+ ),
+ )
+ )
+
+ current_width = width_out
+
+ self.trunk_output = nn.Sequential(OrderedDict(blocks))
+
+ self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+ self.fc = nn.Linear(in_features=current_width, out_features=num_classes)
+
+ # Performs ResNet-style weight initialization
+ for m in self.modules():
+ if isinstance(m, nn.Conv2d):
+ # Note that there is no bias due to BN
+ fan_out = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
+ nn.init.normal_(m.weight, mean=0.0, std=math.sqrt(2.0 / fan_out))
+ elif isinstance(m, nn.BatchNorm2d):
+ nn.init.ones_(m.weight)
+ nn.init.zeros_(m.bias)
+ elif isinstance(m, nn.Linear):
+ nn.init.normal_(m.weight, mean=0.0, std=0.01)
+ nn.init.zeros_(m.bias)
+
+ def forward(self, x: Tensor) -> Tensor:
+ x = self.stem(x)
+ x = self.trunk_output(x)
+
+ x = self.avgpool(x)
+ x = x.flatten(start_dim=1)
+ x = self.fc(x)
+
+ return x
+
+
+def _regnet(
+ block_params: BlockParams,
+ weights: Optional[WeightsEnum],
+ progress: bool,
+ **kwargs: Any,
+) -> RegNet:
+ if weights is not None:
+ _ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"]))
+
+ norm_layer = kwargs.pop("norm_layer", partial(nn.BatchNorm2d, eps=1e-05, momentum=0.1))
+ model = RegNet(block_params, norm_layer=norm_layer, **kwargs)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
+
+
+_COMMON_META: Dict[str, Any] = {
+ "min_size": (1, 1),
+ "categories": _IMAGENET_CATEGORIES,
+}
+
+_COMMON_SWAG_META = {
+ **_COMMON_META,
+ "recipe": "https://github.com/facebookresearch/SWAG",
+ "license": "https://github.com/facebookresearch/SWAG/blob/main/LICENSE",
+}
+
+
+class RegNet_Y_400MF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_400mf-c65dace8.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 4344144,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 74.046,
+ "acc@5": 91.716,
+ }
+ },
+ "_ops": 0.402,
+ "_file_size": 16.806,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_400mf-e6988f5f.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 4344144,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 75.804,
+ "acc@5": 92.742,
+ }
+ },
+ "_ops": 0.402,
+ "_file_size": 16.806,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_Y_800MF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_800mf-1b27b58c.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 6432512,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 76.420,
+ "acc@5": 93.136,
+ }
+ },
+ "_ops": 0.834,
+ "_file_size": 24.774,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_800mf-58fc7688.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 6432512,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 78.828,
+ "acc@5": 94.502,
+ }
+ },
+ "_ops": 0.834,
+ "_file_size": 24.774,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_Y_1_6GF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_1_6gf-b11a554e.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 11202430,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 77.950,
+ "acc@5": 93.966,
+ }
+ },
+ "_ops": 1.612,
+ "_file_size": 43.152,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_1_6gf-0d7bc02a.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 11202430,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 80.876,
+ "acc@5": 95.444,
+ }
+ },
+ "_ops": 1.612,
+ "_file_size": 43.152,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_Y_3_2GF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_3_2gf-b5a9779c.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 19436338,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#medium-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 78.948,
+ "acc@5": 94.576,
+ }
+ },
+ "_ops": 3.176,
+ "_file_size": 74.567,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_3_2gf-9180c971.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 19436338,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 81.982,
+ "acc@5": 95.972,
+ }
+ },
+ "_ops": 3.176,
+ "_file_size": 74.567,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_Y_8GF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_8gf-d0d0e4a8.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 39381472,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#medium-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 80.032,
+ "acc@5": 95.048,
+ }
+ },
+ "_ops": 8.473,
+ "_file_size": 150.701,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_8gf-dc2b1b54.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 39381472,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 82.828,
+ "acc@5": 96.330,
+ }
+ },
+ "_ops": 8.473,
+ "_file_size": 150.701,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_Y_16GF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_16gf-9e6ed7dd.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 83590140,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#large-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 80.424,
+ "acc@5": 95.240,
+ }
+ },
+ "_ops": 15.912,
+ "_file_size": 319.49,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_16gf-3e4a00f9.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 83590140,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 82.886,
+ "acc@5": 96.328,
+ }
+ },
+ "_ops": 15.912,
+ "_file_size": 319.49,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ IMAGENET1K_SWAG_E2E_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_16gf_swag-43afe44d.pth",
+ transforms=partial(
+ ImageClassification, crop_size=384, resize_size=384, interpolation=InterpolationMode.BICUBIC
+ ),
+ meta={
+ **_COMMON_SWAG_META,
+ "num_params": 83590140,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 86.012,
+ "acc@5": 98.054,
+ }
+ },
+ "_ops": 46.735,
+ "_file_size": 319.49,
+ "_docs": """
+ These weights are learnt via transfer learning by end-to-end fine-tuning the original
+ `SWAG `_ weights on ImageNet-1K data.
+ """,
+ },
+ )
+ IMAGENET1K_SWAG_LINEAR_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_16gf_lc_swag-f3ec0043.pth",
+ transforms=partial(
+ ImageClassification, crop_size=224, resize_size=224, interpolation=InterpolationMode.BICUBIC
+ ),
+ meta={
+ **_COMMON_SWAG_META,
+ "recipe": "https://github.com/pytorch/vision/pull/5793",
+ "num_params": 83590140,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 83.976,
+ "acc@5": 97.244,
+ }
+ },
+ "_ops": 15.912,
+ "_file_size": 319.49,
+ "_docs": """
+ These weights are composed of the original frozen `SWAG `_ trunk
+ weights and a linear classifier learnt on top of them trained on ImageNet-1K data.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_Y_32GF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_32gf-4dee3f7a.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 145046770,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#large-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 80.878,
+ "acc@5": 95.340,
+ }
+ },
+ "_ops": 32.28,
+ "_file_size": 554.076,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_32gf-8db6d4b5.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 145046770,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 83.368,
+ "acc@5": 96.498,
+ }
+ },
+ "_ops": 32.28,
+ "_file_size": 554.076,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ IMAGENET1K_SWAG_E2E_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_32gf_swag-04fdfa75.pth",
+ transforms=partial(
+ ImageClassification, crop_size=384, resize_size=384, interpolation=InterpolationMode.BICUBIC
+ ),
+ meta={
+ **_COMMON_SWAG_META,
+ "num_params": 145046770,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 86.838,
+ "acc@5": 98.362,
+ }
+ },
+ "_ops": 94.826,
+ "_file_size": 554.076,
+ "_docs": """
+ These weights are learnt via transfer learning by end-to-end fine-tuning the original
+ `SWAG `_ weights on ImageNet-1K data.
+ """,
+ },
+ )
+ IMAGENET1K_SWAG_LINEAR_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_32gf_lc_swag-e1583746.pth",
+ transforms=partial(
+ ImageClassification, crop_size=224, resize_size=224, interpolation=InterpolationMode.BICUBIC
+ ),
+ meta={
+ **_COMMON_SWAG_META,
+ "recipe": "https://github.com/pytorch/vision/pull/5793",
+ "num_params": 145046770,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 84.622,
+ "acc@5": 97.480,
+ }
+ },
+ "_ops": 32.28,
+ "_file_size": 554.076,
+ "_docs": """
+ These weights are composed of the original frozen `SWAG `_ trunk
+ weights and a linear classifier learnt on top of them trained on ImageNet-1K data.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_Y_128GF_Weights(WeightsEnum):
+ IMAGENET1K_SWAG_E2E_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_128gf_swag-c8ce3e52.pth",
+ transforms=partial(
+ ImageClassification, crop_size=384, resize_size=384, interpolation=InterpolationMode.BICUBIC
+ ),
+ meta={
+ **_COMMON_SWAG_META,
+ "num_params": 644812894,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 88.228,
+ "acc@5": 98.682,
+ }
+ },
+ "_ops": 374.57,
+ "_file_size": 2461.564,
+ "_docs": """
+ These weights are learnt via transfer learning by end-to-end fine-tuning the original
+ `SWAG `_ weights on ImageNet-1K data.
+ """,
+ },
+ )
+ IMAGENET1K_SWAG_LINEAR_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_y_128gf_lc_swag-cbe8ce12.pth",
+ transforms=partial(
+ ImageClassification, crop_size=224, resize_size=224, interpolation=InterpolationMode.BICUBIC
+ ),
+ meta={
+ **_COMMON_SWAG_META,
+ "recipe": "https://github.com/pytorch/vision/pull/5793",
+ "num_params": 644812894,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 86.068,
+ "acc@5": 97.844,
+ }
+ },
+ "_ops": 127.518,
+ "_file_size": 2461.564,
+ "_docs": """
+ These weights are composed of the original frozen `SWAG `_ trunk
+ weights and a linear classifier learnt on top of them trained on ImageNet-1K data.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_SWAG_E2E_V1
+
+
+class RegNet_X_400MF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_400mf-adf1edd5.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 5495976,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 72.834,
+ "acc@5": 90.950,
+ }
+ },
+ "_ops": 0.414,
+ "_file_size": 21.258,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_400mf-62229a5f.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 5495976,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe-with-fixres",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 74.864,
+ "acc@5": 92.322,
+ }
+ },
+ "_ops": 0.414,
+ "_file_size": 21.257,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_X_800MF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_800mf-ad17e45c.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 7259656,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 75.212,
+ "acc@5": 92.348,
+ }
+ },
+ "_ops": 0.8,
+ "_file_size": 27.945,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_800mf-94a99ebd.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 7259656,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe-with-fixres",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 77.522,
+ "acc@5": 93.826,
+ }
+ },
+ "_ops": 0.8,
+ "_file_size": 27.945,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_X_1_6GF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_1_6gf-e3633e7f.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 9190136,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#small-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 77.040,
+ "acc@5": 93.440,
+ }
+ },
+ "_ops": 1.603,
+ "_file_size": 35.339,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_1_6gf-a12f2b72.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 9190136,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe-with-fixres",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 79.668,
+ "acc@5": 94.922,
+ }
+ },
+ "_ops": 1.603,
+ "_file_size": 35.339,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_X_3_2GF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_3_2gf-f342aeae.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 15296552,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#medium-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 78.364,
+ "acc@5": 93.992,
+ }
+ },
+ "_ops": 3.177,
+ "_file_size": 58.756,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_3_2gf-7071aa85.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 15296552,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 81.196,
+ "acc@5": 95.430,
+ }
+ },
+ "_ops": 3.177,
+ "_file_size": 58.756,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_X_8GF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_8gf-03ceed89.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 39572648,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#medium-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 79.344,
+ "acc@5": 94.686,
+ }
+ },
+ "_ops": 7.995,
+ "_file_size": 151.456,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_8gf-2b70d774.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 39572648,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 81.682,
+ "acc@5": 95.678,
+ }
+ },
+ "_ops": 7.995,
+ "_file_size": 151.456,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_X_16GF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_16gf-2007eb11.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 54278536,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#medium-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 80.058,
+ "acc@5": 94.944,
+ }
+ },
+ "_ops": 15.941,
+ "_file_size": 207.627,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_16gf-ba3796d7.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 54278536,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 82.716,
+ "acc@5": 96.196,
+ }
+ },
+ "_ops": 15.941,
+ "_file_size": 207.627,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+class RegNet_X_32GF_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_32gf-9d47f8d0.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "num_params": 107811560,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/classification#large-models",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 80.622,
+ "acc@5": 95.248,
+ }
+ },
+ "_ops": 31.736,
+ "_file_size": 412.039,
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+ },
+ )
+ IMAGENET1K_V2 = Weights(
+ url="https://download.pytorch.org/models/regnet_x_32gf-6eb8fdc6.pth",
+ transforms=partial(ImageClassification, crop_size=224, resize_size=232),
+ meta={
+ **_COMMON_META,
+ "num_params": 107811560,
+ "recipe": "https://github.com/pytorch/vision/issues/3995#new-recipe",
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 83.014,
+ "acc@5": 96.288,
+ }
+ },
+ "_ops": 31.736,
+ "_file_size": 412.039,
+ "_docs": """
+ These weights improve upon the results of the original paper by using a modified version of TorchVision's
+ `new training recipe
+ `_.
+ """,
+ },
+ )
+ DEFAULT = IMAGENET1K_V2
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_Y_400MF_Weights.IMAGENET1K_V1))
+def regnet_y_400mf(*, weights: Optional[RegNet_Y_400MF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetY_400MF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_Y_400MF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_Y_400MF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_Y_400MF_Weights
+ :members:
+ """
+ weights = RegNet_Y_400MF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(depth=16, w_0=48, w_a=27.89, w_m=2.09, group_width=8, se_ratio=0.25, **kwargs)
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_Y_800MF_Weights.IMAGENET1K_V1))
+def regnet_y_800mf(*, weights: Optional[RegNet_Y_800MF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetY_800MF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_Y_800MF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_Y_800MF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_Y_800MF_Weights
+ :members:
+ """
+ weights = RegNet_Y_800MF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(depth=14, w_0=56, w_a=38.84, w_m=2.4, group_width=16, se_ratio=0.25, **kwargs)
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_Y_1_6GF_Weights.IMAGENET1K_V1))
+def regnet_y_1_6gf(*, weights: Optional[RegNet_Y_1_6GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetY_1.6GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_Y_1_6GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_Y_1_6GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_Y_1_6GF_Weights
+ :members:
+ """
+ weights = RegNet_Y_1_6GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(
+ depth=27, w_0=48, w_a=20.71, w_m=2.65, group_width=24, se_ratio=0.25, **kwargs
+ )
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_Y_3_2GF_Weights.IMAGENET1K_V1))
+def regnet_y_3_2gf(*, weights: Optional[RegNet_Y_3_2GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetY_3.2GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_Y_3_2GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_Y_3_2GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_Y_3_2GF_Weights
+ :members:
+ """
+ weights = RegNet_Y_3_2GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(
+ depth=21, w_0=80, w_a=42.63, w_m=2.66, group_width=24, se_ratio=0.25, **kwargs
+ )
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_Y_8GF_Weights.IMAGENET1K_V1))
+def regnet_y_8gf(*, weights: Optional[RegNet_Y_8GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetY_8GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_Y_8GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_Y_8GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_Y_8GF_Weights
+ :members:
+ """
+ weights = RegNet_Y_8GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(
+ depth=17, w_0=192, w_a=76.82, w_m=2.19, group_width=56, se_ratio=0.25, **kwargs
+ )
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_Y_16GF_Weights.IMAGENET1K_V1))
+def regnet_y_16gf(*, weights: Optional[RegNet_Y_16GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetY_16GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_Y_16GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_Y_16GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_Y_16GF_Weights
+ :members:
+ """
+ weights = RegNet_Y_16GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(
+ depth=18, w_0=200, w_a=106.23, w_m=2.48, group_width=112, se_ratio=0.25, **kwargs
+ )
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_Y_32GF_Weights.IMAGENET1K_V1))
+def regnet_y_32gf(*, weights: Optional[RegNet_Y_32GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetY_32GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_Y_32GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_Y_32GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_Y_32GF_Weights
+ :members:
+ """
+ weights = RegNet_Y_32GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(
+ depth=20, w_0=232, w_a=115.89, w_m=2.53, group_width=232, se_ratio=0.25, **kwargs
+ )
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", None))
+def regnet_y_128gf(*, weights: Optional[RegNet_Y_128GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetY_128GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_Y_128GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_Y_128GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_Y_128GF_Weights
+ :members:
+ """
+ weights = RegNet_Y_128GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(
+ depth=27, w_0=456, w_a=160.83, w_m=2.52, group_width=264, se_ratio=0.25, **kwargs
+ )
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_X_400MF_Weights.IMAGENET1K_V1))
+def regnet_x_400mf(*, weights: Optional[RegNet_X_400MF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetX_400MF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_X_400MF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_X_400MF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_X_400MF_Weights
+ :members:
+ """
+ weights = RegNet_X_400MF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(depth=22, w_0=24, w_a=24.48, w_m=2.54, group_width=16, **kwargs)
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_X_800MF_Weights.IMAGENET1K_V1))
+def regnet_x_800mf(*, weights: Optional[RegNet_X_800MF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetX_800MF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_X_800MF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_X_800MF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_X_800MF_Weights
+ :members:
+ """
+ weights = RegNet_X_800MF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(depth=16, w_0=56, w_a=35.73, w_m=2.28, group_width=16, **kwargs)
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_X_1_6GF_Weights.IMAGENET1K_V1))
+def regnet_x_1_6gf(*, weights: Optional[RegNet_X_1_6GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetX_1.6GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_X_1_6GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_X_1_6GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_X_1_6GF_Weights
+ :members:
+ """
+ weights = RegNet_X_1_6GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(depth=18, w_0=80, w_a=34.01, w_m=2.25, group_width=24, **kwargs)
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_X_3_2GF_Weights.IMAGENET1K_V1))
+def regnet_x_3_2gf(*, weights: Optional[RegNet_X_3_2GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetX_3.2GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_X_3_2GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_X_3_2GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_X_3_2GF_Weights
+ :members:
+ """
+ weights = RegNet_X_3_2GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(depth=25, w_0=88, w_a=26.31, w_m=2.25, group_width=48, **kwargs)
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_X_8GF_Weights.IMAGENET1K_V1))
+def regnet_x_8gf(*, weights: Optional[RegNet_X_8GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetX_8GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_X_8GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_X_8GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_X_8GF_Weights
+ :members:
+ """
+ weights = RegNet_X_8GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(depth=23, w_0=80, w_a=49.56, w_m=2.88, group_width=120, **kwargs)
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_X_16GF_Weights.IMAGENET1K_V1))
+def regnet_x_16gf(*, weights: Optional[RegNet_X_16GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetX_16GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_X_16GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_X_16GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_X_16GF_Weights
+ :members:
+ """
+ weights = RegNet_X_16GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(depth=22, w_0=216, w_a=55.59, w_m=2.1, group_width=128, **kwargs)
+ return _regnet(params, weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", RegNet_X_32GF_Weights.IMAGENET1K_V1))
+def regnet_x_32gf(*, weights: Optional[RegNet_X_32GF_Weights] = None, progress: bool = True, **kwargs: Any) -> RegNet:
+ """
+ Constructs a RegNetX_32GF architecture from
+ `Designing Network Design Spaces `_.
+
+ Args:
+ weights (:class:`~torchvision.models.RegNet_X_32GF_Weights`, optional): The pretrained weights to use.
+ See :class:`~torchvision.models.RegNet_X_32GF_Weights` below for more details and possible values.
+ By default, no pretrained weights are used.
+ progress (bool, optional): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to either ``torchvision.models.regnet.RegNet`` or
+ ``torchvision.models.regnet.BlockParams`` class. Please refer to the `source code
+ `_
+ for more detail about the classes.
+
+ .. autoclass:: torchvision.models.RegNet_X_32GF_Weights
+ :members:
+ """
+ weights = RegNet_X_32GF_Weights.verify(weights)
+
+ params = BlockParams.from_init_params(depth=23, w_0=320, w_a=69.86, w_m=2.0, group_width=168, **kwargs)
+ return _regnet(params, weights, progress, **kwargs)
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__init__.py b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..3d6f37f958a131b76ce80306718b77d78bc3f045
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__init__.py
@@ -0,0 +1,3 @@
+from .deeplabv3 import *
+from .fcn import *
+from .lraspp import *
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__pycache__/_utils.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__pycache__/_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f33c8cedd664cd8a6b947a5427514a63576c5128
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__pycache__/_utils.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__pycache__/fcn.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__pycache__/fcn.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..827f1c5080f93613b580b848667ba2f2993e74bc
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__pycache__/fcn.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__pycache__/lraspp.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__pycache__/lraspp.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..e868bcc8624aa5b7a98d7c342d1111ea3132fd98
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/__pycache__/lraspp.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/_utils.py b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/_utils.py
new file mode 100644
index 0000000000000000000000000000000000000000..56560e9dab5c143699c918fa28236a902e530daf
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/_utils.py
@@ -0,0 +1,37 @@
+from collections import OrderedDict
+from typing import Dict, Optional
+
+from torch import nn, Tensor
+from torch.nn import functional as F
+
+from ...utils import _log_api_usage_once
+
+
+class _SimpleSegmentationModel(nn.Module):
+ __constants__ = ["aux_classifier"]
+
+ def __init__(self, backbone: nn.Module, classifier: nn.Module, aux_classifier: Optional[nn.Module] = None) -> None:
+ super().__init__()
+ _log_api_usage_once(self)
+ self.backbone = backbone
+ self.classifier = classifier
+ self.aux_classifier = aux_classifier
+
+ def forward(self, x: Tensor) -> Dict[str, Tensor]:
+ input_shape = x.shape[-2:]
+ # contract: features is a dict of tensors
+ features = self.backbone(x)
+
+ result = OrderedDict()
+ x = features["out"]
+ x = self.classifier(x)
+ x = F.interpolate(x, size=input_shape, mode="bilinear", align_corners=False)
+ result["out"] = x
+
+ if self.aux_classifier is not None:
+ x = features["aux"]
+ x = self.aux_classifier(x)
+ x = F.interpolate(x, size=input_shape, mode="bilinear", align_corners=False)
+ result["aux"] = x
+
+ return result
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/deeplabv3.py b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/deeplabv3.py
new file mode 100644
index 0000000000000000000000000000000000000000..5f615d2c9f04aff24a9cd440e6363143bd64db7d
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/segmentation/deeplabv3.py
@@ -0,0 +1,390 @@
+from functools import partial
+from typing import Any, List, Optional
+
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from ...transforms._presets import SemanticSegmentation
+from .._api import register_model, Weights, WeightsEnum
+from .._meta import _VOC_CATEGORIES
+from .._utils import _ovewrite_value_param, handle_legacy_interface, IntermediateLayerGetter
+from ..mobilenetv3 import mobilenet_v3_large, MobileNet_V3_Large_Weights, MobileNetV3
+from ..resnet import ResNet, resnet101, ResNet101_Weights, resnet50, ResNet50_Weights
+from ._utils import _SimpleSegmentationModel
+from .fcn import FCNHead
+
+
+__all__ = [
+ "DeepLabV3",
+ "DeepLabV3_ResNet50_Weights",
+ "DeepLabV3_ResNet101_Weights",
+ "DeepLabV3_MobileNet_V3_Large_Weights",
+ "deeplabv3_mobilenet_v3_large",
+ "deeplabv3_resnet50",
+ "deeplabv3_resnet101",
+]
+
+
+class DeepLabV3(_SimpleSegmentationModel):
+ """
+ Implements DeepLabV3 model from
+ `"Rethinking Atrous Convolution for Semantic Image Segmentation"
+ `_.
+
+ Args:
+ backbone (nn.Module): the network used to compute the features for the model.
+ The backbone should return an OrderedDict[Tensor], with the key being
+ "out" for the last feature map used, and "aux" if an auxiliary classifier
+ is used.
+ classifier (nn.Module): module that takes the "out" element returned from
+ the backbone and returns a dense prediction.
+ aux_classifier (nn.Module, optional): auxiliary classifier used during training
+ """
+
+ pass
+
+
+class DeepLabHead(nn.Sequential):
+ def __init__(self, in_channels: int, num_classes: int) -> None:
+ super().__init__(
+ ASPP(in_channels, [12, 24, 36]),
+ nn.Conv2d(256, 256, 3, padding=1, bias=False),
+ nn.BatchNorm2d(256),
+ nn.ReLU(),
+ nn.Conv2d(256, num_classes, 1),
+ )
+
+
+class ASPPConv(nn.Sequential):
+ def __init__(self, in_channels: int, out_channels: int, dilation: int) -> None:
+ modules = [
+ nn.Conv2d(in_channels, out_channels, 3, padding=dilation, dilation=dilation, bias=False),
+ nn.BatchNorm2d(out_channels),
+ nn.ReLU(),
+ ]
+ super().__init__(*modules)
+
+
+class ASPPPooling(nn.Sequential):
+ def __init__(self, in_channels: int, out_channels: int) -> None:
+ super().__init__(
+ nn.AdaptiveAvgPool2d(1),
+ nn.Conv2d(in_channels, out_channels, 1, bias=False),
+ nn.BatchNorm2d(out_channels),
+ nn.ReLU(),
+ )
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ size = x.shape[-2:]
+ for mod in self:
+ x = mod(x)
+ return F.interpolate(x, size=size, mode="bilinear", align_corners=False)
+
+
+class ASPP(nn.Module):
+ def __init__(self, in_channels: int, atrous_rates: List[int], out_channels: int = 256) -> None:
+ super().__init__()
+ modules = []
+ modules.append(
+ nn.Sequential(nn.Conv2d(in_channels, out_channels, 1, bias=False), nn.BatchNorm2d(out_channels), nn.ReLU())
+ )
+
+ rates = tuple(atrous_rates)
+ for rate in rates:
+ modules.append(ASPPConv(in_channels, out_channels, rate))
+
+ modules.append(ASPPPooling(in_channels, out_channels))
+
+ self.convs = nn.ModuleList(modules)
+
+ self.project = nn.Sequential(
+ nn.Conv2d(len(self.convs) * out_channels, out_channels, 1, bias=False),
+ nn.BatchNorm2d(out_channels),
+ nn.ReLU(),
+ nn.Dropout(0.5),
+ )
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ _res = []
+ for conv in self.convs:
+ _res.append(conv(x))
+ res = torch.cat(_res, dim=1)
+ return self.project(res)
+
+
+def _deeplabv3_resnet(
+ backbone: ResNet,
+ num_classes: int,
+ aux: Optional[bool],
+) -> DeepLabV3:
+ return_layers = {"layer4": "out"}
+ if aux:
+ return_layers["layer3"] = "aux"
+ backbone = IntermediateLayerGetter(backbone, return_layers=return_layers)
+
+ aux_classifier = FCNHead(1024, num_classes) if aux else None
+ classifier = DeepLabHead(2048, num_classes)
+ return DeepLabV3(backbone, classifier, aux_classifier)
+
+
+_COMMON_META = {
+ "categories": _VOC_CATEGORIES,
+ "min_size": (1, 1),
+ "_docs": """
+ These weights were trained on a subset of COCO, using only the 20 categories that are present in the Pascal VOC
+ dataset.
+ """,
+}
+
+
+class DeepLabV3_ResNet50_Weights(WeightsEnum):
+ COCO_WITH_VOC_LABELS_V1 = Weights(
+ url="https://download.pytorch.org/models/deeplabv3_resnet50_coco-cd0a2569.pth",
+ transforms=partial(SemanticSegmentation, resize_size=520),
+ meta={
+ **_COMMON_META,
+ "num_params": 42004074,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/segmentation#deeplabv3_resnet50",
+ "_metrics": {
+ "COCO-val2017-VOC-labels": {
+ "miou": 66.4,
+ "pixel_acc": 92.4,
+ }
+ },
+ "_ops": 178.722,
+ "_file_size": 160.515,
+ },
+ )
+ DEFAULT = COCO_WITH_VOC_LABELS_V1
+
+
+class DeepLabV3_ResNet101_Weights(WeightsEnum):
+ COCO_WITH_VOC_LABELS_V1 = Weights(
+ url="https://download.pytorch.org/models/deeplabv3_resnet101_coco-586e9e4e.pth",
+ transforms=partial(SemanticSegmentation, resize_size=520),
+ meta={
+ **_COMMON_META,
+ "num_params": 60996202,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/segmentation#fcn_resnet101",
+ "_metrics": {
+ "COCO-val2017-VOC-labels": {
+ "miou": 67.4,
+ "pixel_acc": 92.4,
+ }
+ },
+ "_ops": 258.743,
+ "_file_size": 233.217,
+ },
+ )
+ DEFAULT = COCO_WITH_VOC_LABELS_V1
+
+
+class DeepLabV3_MobileNet_V3_Large_Weights(WeightsEnum):
+ COCO_WITH_VOC_LABELS_V1 = Weights(
+ url="https://download.pytorch.org/models/deeplabv3_mobilenet_v3_large-fc3c493d.pth",
+ transforms=partial(SemanticSegmentation, resize_size=520),
+ meta={
+ **_COMMON_META,
+ "num_params": 11029328,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/segmentation#deeplabv3_mobilenet_v3_large",
+ "_metrics": {
+ "COCO-val2017-VOC-labels": {
+ "miou": 60.3,
+ "pixel_acc": 91.2,
+ }
+ },
+ "_ops": 10.452,
+ "_file_size": 42.301,
+ },
+ )
+ DEFAULT = COCO_WITH_VOC_LABELS_V1
+
+
+def _deeplabv3_mobilenetv3(
+ backbone: MobileNetV3,
+ num_classes: int,
+ aux: Optional[bool],
+) -> DeepLabV3:
+ backbone = backbone.features
+ # Gather the indices of blocks which are strided. These are the locations of C1, ..., Cn-1 blocks.
+ # The first and last blocks are always included because they are the C0 (conv1) and Cn.
+ stage_indices = [0] + [i for i, b in enumerate(backbone) if getattr(b, "_is_cn", False)] + [len(backbone) - 1]
+ out_pos = stage_indices[-1] # use C5 which has output_stride = 16
+ out_inplanes = backbone[out_pos].out_channels
+ aux_pos = stage_indices[-4] # use C2 here which has output_stride = 8
+ aux_inplanes = backbone[aux_pos].out_channels
+ return_layers = {str(out_pos): "out"}
+ if aux:
+ return_layers[str(aux_pos)] = "aux"
+ backbone = IntermediateLayerGetter(backbone, return_layers=return_layers)
+
+ aux_classifier = FCNHead(aux_inplanes, num_classes) if aux else None
+ classifier = DeepLabHead(out_inplanes, num_classes)
+ return DeepLabV3(backbone, classifier, aux_classifier)
+
+
+@register_model()
+@handle_legacy_interface(
+ weights=("pretrained", DeepLabV3_ResNet50_Weights.COCO_WITH_VOC_LABELS_V1),
+ weights_backbone=("pretrained_backbone", ResNet50_Weights.IMAGENET1K_V1),
+)
+def deeplabv3_resnet50(
+ *,
+ weights: Optional[DeepLabV3_ResNet50_Weights] = None,
+ progress: bool = True,
+ num_classes: Optional[int] = None,
+ aux_loss: Optional[bool] = None,
+ weights_backbone: Optional[ResNet50_Weights] = ResNet50_Weights.IMAGENET1K_V1,
+ **kwargs: Any,
+) -> DeepLabV3:
+ """Constructs a DeepLabV3 model with a ResNet-50 backbone.
+
+ .. betastatus:: segmentation module
+
+ Reference: `Rethinking Atrous Convolution for Semantic Image Segmentation `__.
+
+ Args:
+ weights (:class:`~torchvision.models.segmentation.DeepLabV3_ResNet50_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.segmentation.DeepLabV3_ResNet50_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ num_classes (int, optional): number of output classes of the model (including the background)
+ aux_loss (bool, optional): If True, it uses an auxiliary loss
+ weights_backbone (:class:`~torchvision.models.ResNet50_Weights`, optional): The pretrained weights for the
+ backbone
+ **kwargs: unused
+
+ .. autoclass:: torchvision.models.segmentation.DeepLabV3_ResNet50_Weights
+ :members:
+ """
+ weights = DeepLabV3_ResNet50_Weights.verify(weights)
+ weights_backbone = ResNet50_Weights.verify(weights_backbone)
+
+ if weights is not None:
+ weights_backbone = None
+ num_classes = _ovewrite_value_param("num_classes", num_classes, len(weights.meta["categories"]))
+ aux_loss = _ovewrite_value_param("aux_loss", aux_loss, True)
+ elif num_classes is None:
+ num_classes = 21
+
+ backbone = resnet50(weights=weights_backbone, replace_stride_with_dilation=[False, True, True])
+ model = _deeplabv3_resnet(backbone, num_classes, aux_loss)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
+
+
+@register_model()
+@handle_legacy_interface(
+ weights=("pretrained", DeepLabV3_ResNet101_Weights.COCO_WITH_VOC_LABELS_V1),
+ weights_backbone=("pretrained_backbone", ResNet101_Weights.IMAGENET1K_V1),
+)
+def deeplabv3_resnet101(
+ *,
+ weights: Optional[DeepLabV3_ResNet101_Weights] = None,
+ progress: bool = True,
+ num_classes: Optional[int] = None,
+ aux_loss: Optional[bool] = None,
+ weights_backbone: Optional[ResNet101_Weights] = ResNet101_Weights.IMAGENET1K_V1,
+ **kwargs: Any,
+) -> DeepLabV3:
+ """Constructs a DeepLabV3 model with a ResNet-101 backbone.
+
+ .. betastatus:: segmentation module
+
+ Reference: `Rethinking Atrous Convolution for Semantic Image Segmentation `__.
+
+ Args:
+ weights (:class:`~torchvision.models.segmentation.DeepLabV3_ResNet101_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.segmentation.DeepLabV3_ResNet101_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ num_classes (int, optional): number of output classes of the model (including the background)
+ aux_loss (bool, optional): If True, it uses an auxiliary loss
+ weights_backbone (:class:`~torchvision.models.ResNet101_Weights`, optional): The pretrained weights for the
+ backbone
+ **kwargs: unused
+
+ .. autoclass:: torchvision.models.segmentation.DeepLabV3_ResNet101_Weights
+ :members:
+ """
+ weights = DeepLabV3_ResNet101_Weights.verify(weights)
+ weights_backbone = ResNet101_Weights.verify(weights_backbone)
+
+ if weights is not None:
+ weights_backbone = None
+ num_classes = _ovewrite_value_param("num_classes", num_classes, len(weights.meta["categories"]))
+ aux_loss = _ovewrite_value_param("aux_loss", aux_loss, True)
+ elif num_classes is None:
+ num_classes = 21
+
+ backbone = resnet101(weights=weights_backbone, replace_stride_with_dilation=[False, True, True])
+ model = _deeplabv3_resnet(backbone, num_classes, aux_loss)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
+
+
+@register_model()
+@handle_legacy_interface(
+ weights=("pretrained", DeepLabV3_MobileNet_V3_Large_Weights.COCO_WITH_VOC_LABELS_V1),
+ weights_backbone=("pretrained_backbone", MobileNet_V3_Large_Weights.IMAGENET1K_V1),
+)
+def deeplabv3_mobilenet_v3_large(
+ *,
+ weights: Optional[DeepLabV3_MobileNet_V3_Large_Weights] = None,
+ progress: bool = True,
+ num_classes: Optional[int] = None,
+ aux_loss: Optional[bool] = None,
+ weights_backbone: Optional[MobileNet_V3_Large_Weights] = MobileNet_V3_Large_Weights.IMAGENET1K_V1,
+ **kwargs: Any,
+) -> DeepLabV3:
+ """Constructs a DeepLabV3 model with a MobileNetV3-Large backbone.
+
+ Reference: `Rethinking Atrous Convolution for Semantic Image Segmentation `__.
+
+ Args:
+ weights (:class:`~torchvision.models.segmentation.DeepLabV3_MobileNet_V3_Large_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.segmentation.DeepLabV3_MobileNet_V3_Large_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ num_classes (int, optional): number of output classes of the model (including the background)
+ aux_loss (bool, optional): If True, it uses an auxiliary loss
+ weights_backbone (:class:`~torchvision.models.MobileNet_V3_Large_Weights`, optional): The pretrained weights
+ for the backbone
+ **kwargs: unused
+
+ .. autoclass:: torchvision.models.segmentation.DeepLabV3_MobileNet_V3_Large_Weights
+ :members:
+ """
+ weights = DeepLabV3_MobileNet_V3_Large_Weights.verify(weights)
+ weights_backbone = MobileNet_V3_Large_Weights.verify(weights_backbone)
+
+ if weights is not None:
+ weights_backbone = None
+ num_classes = _ovewrite_value_param("num_classes", num_classes, len(weights.meta["categories"]))
+ aux_loss = _ovewrite_value_param("aux_loss", aux_loss, True)
+ elif num_classes is None:
+ num_classes = 21
+
+ backbone = mobilenet_v3_large(weights=weights_backbone, dilated=True)
+ model = _deeplabv3_mobilenetv3(backbone, num_classes, aux_loss)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/squeezenet.py b/wemm/lib/python3.10/site-packages/torchvision/models/squeezenet.py
new file mode 100644
index 0000000000000000000000000000000000000000..84097c2400023e11829427f24832b4751359f5eb
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/squeezenet.py
@@ -0,0 +1,223 @@
+from functools import partial
+from typing import Any, Optional
+
+import torch
+import torch.nn as nn
+import torch.nn.init as init
+
+from ..transforms._presets import ImageClassification
+from ..utils import _log_api_usage_once
+from ._api import register_model, Weights, WeightsEnum
+from ._meta import _IMAGENET_CATEGORIES
+from ._utils import _ovewrite_named_param, handle_legacy_interface
+
+
+__all__ = ["SqueezeNet", "SqueezeNet1_0_Weights", "SqueezeNet1_1_Weights", "squeezenet1_0", "squeezenet1_1"]
+
+
+class Fire(nn.Module):
+ def __init__(self, inplanes: int, squeeze_planes: int, expand1x1_planes: int, expand3x3_planes: int) -> None:
+ super().__init__()
+ self.inplanes = inplanes
+ self.squeeze = nn.Conv2d(inplanes, squeeze_planes, kernel_size=1)
+ self.squeeze_activation = nn.ReLU(inplace=True)
+ self.expand1x1 = nn.Conv2d(squeeze_planes, expand1x1_planes, kernel_size=1)
+ self.expand1x1_activation = nn.ReLU(inplace=True)
+ self.expand3x3 = nn.Conv2d(squeeze_planes, expand3x3_planes, kernel_size=3, padding=1)
+ self.expand3x3_activation = nn.ReLU(inplace=True)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ x = self.squeeze_activation(self.squeeze(x))
+ return torch.cat(
+ [self.expand1x1_activation(self.expand1x1(x)), self.expand3x3_activation(self.expand3x3(x))], 1
+ )
+
+
+class SqueezeNet(nn.Module):
+ def __init__(self, version: str = "1_0", num_classes: int = 1000, dropout: float = 0.5) -> None:
+ super().__init__()
+ _log_api_usage_once(self)
+ self.num_classes = num_classes
+ if version == "1_0":
+ self.features = nn.Sequential(
+ nn.Conv2d(3, 96, kernel_size=7, stride=2),
+ nn.ReLU(inplace=True),
+ nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
+ Fire(96, 16, 64, 64),
+ Fire(128, 16, 64, 64),
+ Fire(128, 32, 128, 128),
+ nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
+ Fire(256, 32, 128, 128),
+ Fire(256, 48, 192, 192),
+ Fire(384, 48, 192, 192),
+ Fire(384, 64, 256, 256),
+ nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
+ Fire(512, 64, 256, 256),
+ )
+ elif version == "1_1":
+ self.features = nn.Sequential(
+ nn.Conv2d(3, 64, kernel_size=3, stride=2),
+ nn.ReLU(inplace=True),
+ nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
+ Fire(64, 16, 64, 64),
+ Fire(128, 16, 64, 64),
+ nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
+ Fire(128, 32, 128, 128),
+ Fire(256, 32, 128, 128),
+ nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
+ Fire(256, 48, 192, 192),
+ Fire(384, 48, 192, 192),
+ Fire(384, 64, 256, 256),
+ Fire(512, 64, 256, 256),
+ )
+ else:
+ # FIXME: Is this needed? SqueezeNet should only be called from the
+ # FIXME: squeezenet1_x() functions
+ # FIXME: This checking is not done for the other models
+ raise ValueError(f"Unsupported SqueezeNet version {version}: 1_0 or 1_1 expected")
+
+ # Final convolution is initialized differently from the rest
+ final_conv = nn.Conv2d(512, self.num_classes, kernel_size=1)
+ self.classifier = nn.Sequential(
+ nn.Dropout(p=dropout), final_conv, nn.ReLU(inplace=True), nn.AdaptiveAvgPool2d((1, 1))
+ )
+
+ for m in self.modules():
+ if isinstance(m, nn.Conv2d):
+ if m is final_conv:
+ init.normal_(m.weight, mean=0.0, std=0.01)
+ else:
+ init.kaiming_uniform_(m.weight)
+ if m.bias is not None:
+ init.constant_(m.bias, 0)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ x = self.features(x)
+ x = self.classifier(x)
+ return torch.flatten(x, 1)
+
+
+def _squeezenet(
+ version: str,
+ weights: Optional[WeightsEnum],
+ progress: bool,
+ **kwargs: Any,
+) -> SqueezeNet:
+ if weights is not None:
+ _ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"]))
+
+ model = SqueezeNet(version, **kwargs)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
+
+
+_COMMON_META = {
+ "categories": _IMAGENET_CATEGORIES,
+ "recipe": "https://github.com/pytorch/vision/pull/49#issuecomment-277560717",
+ "_docs": """These weights reproduce closely the results of the paper using a simple training recipe.""",
+}
+
+
+class SqueezeNet1_0_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/squeezenet1_0-b66bff10.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "min_size": (21, 21),
+ "num_params": 1248424,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 58.092,
+ "acc@5": 80.420,
+ }
+ },
+ "_ops": 0.819,
+ "_file_size": 4.778,
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+class SqueezeNet1_1_Weights(WeightsEnum):
+ IMAGENET1K_V1 = Weights(
+ url="https://download.pytorch.org/models/squeezenet1_1-b8a52dc0.pth",
+ transforms=partial(ImageClassification, crop_size=224),
+ meta={
+ **_COMMON_META,
+ "min_size": (17, 17),
+ "num_params": 1235496,
+ "_metrics": {
+ "ImageNet-1K": {
+ "acc@1": 58.178,
+ "acc@5": 80.624,
+ }
+ },
+ "_ops": 0.349,
+ "_file_size": 4.729,
+ },
+ )
+ DEFAULT = IMAGENET1K_V1
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", SqueezeNet1_0_Weights.IMAGENET1K_V1))
+def squeezenet1_0(
+ *, weights: Optional[SqueezeNet1_0_Weights] = None, progress: bool = True, **kwargs: Any
+) -> SqueezeNet:
+ """SqueezeNet model architecture from the `SqueezeNet: AlexNet-level
+ accuracy with 50x fewer parameters and <0.5MB model size
+ `_ paper.
+
+ Args:
+ weights (:class:`~torchvision.models.SqueezeNet1_0_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.SqueezeNet1_0_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.squeezenet.SqueezeNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.SqueezeNet1_0_Weights
+ :members:
+ """
+ weights = SqueezeNet1_0_Weights.verify(weights)
+ return _squeezenet("1_0", weights, progress, **kwargs)
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", SqueezeNet1_1_Weights.IMAGENET1K_V1))
+def squeezenet1_1(
+ *, weights: Optional[SqueezeNet1_1_Weights] = None, progress: bool = True, **kwargs: Any
+) -> SqueezeNet:
+ """SqueezeNet 1.1 model from the `official SqueezeNet repo
+ `_.
+
+ SqueezeNet 1.1 has 2.4x less computation and slightly fewer parameters
+ than SqueezeNet 1.0, without sacrificing accuracy.
+
+ Args:
+ weights (:class:`~torchvision.models.SqueezeNet1_1_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.SqueezeNet1_1_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.squeezenet.SqueezeNet``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.SqueezeNet1_1_Weights
+ :members:
+ """
+ weights = SqueezeNet1_1_Weights.verify(weights)
+ return _squeezenet("1_1", weights, progress, **kwargs)
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/video/__init__.py b/wemm/lib/python3.10/site-packages/torchvision/models/video/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..f1eedd3116001af22ec202d2ccec6eefad8090ae
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/video/__init__.py
@@ -0,0 +1,4 @@
+from .mvit import *
+from .resnet import *
+from .s3d import *
+from .swin_transformer import *
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/video/__pycache__/mvit.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/video/__pycache__/mvit.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..0daa951f0500356d1fabe893732be8e528b03196
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/video/__pycache__/mvit.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/video/__pycache__/resnet.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/models/video/__pycache__/resnet.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..38932ea371e24b27bee048ab2d92235ff6fdf9ce
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/models/video/__pycache__/resnet.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/video/mvit.py b/wemm/lib/python3.10/site-packages/torchvision/models/video/mvit.py
new file mode 100644
index 0000000000000000000000000000000000000000..d3be03740125b45b867da85fae33fbcbc12beded
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/video/mvit.py
@@ -0,0 +1,896 @@
+import math
+from dataclasses import dataclass
+from functools import partial
+from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
+
+import torch
+import torch.fx
+import torch.nn as nn
+
+from ...ops import MLP, StochasticDepth
+from ...transforms._presets import VideoClassification
+from ...utils import _log_api_usage_once
+from .._api import register_model, Weights, WeightsEnum
+from .._meta import _KINETICS400_CATEGORIES
+from .._utils import _ovewrite_named_param, handle_legacy_interface
+
+
+__all__ = [
+ "MViT",
+ "MViT_V1_B_Weights",
+ "mvit_v1_b",
+ "MViT_V2_S_Weights",
+ "mvit_v2_s",
+]
+
+
+@dataclass
+class MSBlockConfig:
+ num_heads: int
+ input_channels: int
+ output_channels: int
+ kernel_q: List[int]
+ kernel_kv: List[int]
+ stride_q: List[int]
+ stride_kv: List[int]
+
+
+def _prod(s: Sequence[int]) -> int:
+ product = 1
+ for v in s:
+ product *= v
+ return product
+
+
+def _unsqueeze(x: torch.Tensor, target_dim: int, expand_dim: int) -> Tuple[torch.Tensor, int]:
+ tensor_dim = x.dim()
+ if tensor_dim == target_dim - 1:
+ x = x.unsqueeze(expand_dim)
+ elif tensor_dim != target_dim:
+ raise ValueError(f"Unsupported input dimension {x.shape}")
+ return x, tensor_dim
+
+
+def _squeeze(x: torch.Tensor, target_dim: int, expand_dim: int, tensor_dim: int) -> torch.Tensor:
+ if tensor_dim == target_dim - 1:
+ x = x.squeeze(expand_dim)
+ return x
+
+
+torch.fx.wrap("_unsqueeze")
+torch.fx.wrap("_squeeze")
+
+
+class Pool(nn.Module):
+ def __init__(
+ self,
+ pool: nn.Module,
+ norm: Optional[nn.Module],
+ activation: Optional[nn.Module] = None,
+ norm_before_pool: bool = False,
+ ) -> None:
+ super().__init__()
+ self.pool = pool
+ layers = []
+ if norm is not None:
+ layers.append(norm)
+ if activation is not None:
+ layers.append(activation)
+ self.norm_act = nn.Sequential(*layers) if layers else None
+ self.norm_before_pool = norm_before_pool
+
+ def forward(self, x: torch.Tensor, thw: Tuple[int, int, int]) -> Tuple[torch.Tensor, Tuple[int, int, int]]:
+ x, tensor_dim = _unsqueeze(x, 4, 1)
+
+ # Separate the class token and reshape the input
+ class_token, x = torch.tensor_split(x, indices=(1,), dim=2)
+ x = x.transpose(2, 3)
+ B, N, C = x.shape[:3]
+ x = x.reshape((B * N, C) + thw).contiguous()
+
+ # normalizing prior pooling is useful when we use BN which can be absorbed to speed up inference
+ if self.norm_before_pool and self.norm_act is not None:
+ x = self.norm_act(x)
+
+ # apply the pool on the input and add back the token
+ x = self.pool(x)
+ T, H, W = x.shape[2:]
+ x = x.reshape(B, N, C, -1).transpose(2, 3)
+ x = torch.cat((class_token, x), dim=2)
+
+ if not self.norm_before_pool and self.norm_act is not None:
+ x = self.norm_act(x)
+
+ x = _squeeze(x, 4, 1, tensor_dim)
+ return x, (T, H, W)
+
+
+def _interpolate(embedding: torch.Tensor, d: int) -> torch.Tensor:
+ if embedding.shape[0] == d:
+ return embedding
+
+ return (
+ nn.functional.interpolate(
+ embedding.permute(1, 0).unsqueeze(0),
+ size=d,
+ mode="linear",
+ )
+ .squeeze(0)
+ .permute(1, 0)
+ )
+
+
+def _add_rel_pos(
+ attn: torch.Tensor,
+ q: torch.Tensor,
+ q_thw: Tuple[int, int, int],
+ k_thw: Tuple[int, int, int],
+ rel_pos_h: torch.Tensor,
+ rel_pos_w: torch.Tensor,
+ rel_pos_t: torch.Tensor,
+) -> torch.Tensor:
+ # Modified code from: https://github.com/facebookresearch/SlowFast/commit/1aebd71a2efad823d52b827a3deaf15a56cf4932
+ q_t, q_h, q_w = q_thw
+ k_t, k_h, k_w = k_thw
+ dh = int(2 * max(q_h, k_h) - 1)
+ dw = int(2 * max(q_w, k_w) - 1)
+ dt = int(2 * max(q_t, k_t) - 1)
+
+ # Scale up rel pos if shapes for q and k are different.
+ q_h_ratio = max(k_h / q_h, 1.0)
+ k_h_ratio = max(q_h / k_h, 1.0)
+ dist_h = torch.arange(q_h)[:, None] * q_h_ratio - (torch.arange(k_h)[None, :] + (1.0 - k_h)) * k_h_ratio
+ q_w_ratio = max(k_w / q_w, 1.0)
+ k_w_ratio = max(q_w / k_w, 1.0)
+ dist_w = torch.arange(q_w)[:, None] * q_w_ratio - (torch.arange(k_w)[None, :] + (1.0 - k_w)) * k_w_ratio
+ q_t_ratio = max(k_t / q_t, 1.0)
+ k_t_ratio = max(q_t / k_t, 1.0)
+ dist_t = torch.arange(q_t)[:, None] * q_t_ratio - (torch.arange(k_t)[None, :] + (1.0 - k_t)) * k_t_ratio
+
+ # Interpolate rel pos if needed.
+ rel_pos_h = _interpolate(rel_pos_h, dh)
+ rel_pos_w = _interpolate(rel_pos_w, dw)
+ rel_pos_t = _interpolate(rel_pos_t, dt)
+ Rh = rel_pos_h[dist_h.long()]
+ Rw = rel_pos_w[dist_w.long()]
+ Rt = rel_pos_t[dist_t.long()]
+
+ B, n_head, _, dim = q.shape
+
+ r_q = q[:, :, 1:].reshape(B, n_head, q_t, q_h, q_w, dim)
+ rel_h_q = torch.einsum("bythwc,hkc->bythwk", r_q, Rh) # [B, H, q_t, qh, qw, k_h]
+ rel_w_q = torch.einsum("bythwc,wkc->bythwk", r_q, Rw) # [B, H, q_t, qh, qw, k_w]
+ # [B, H, q_t, q_h, q_w, dim] -> [q_t, B, H, q_h, q_w, dim] -> [q_t, B*H*q_h*q_w, dim]
+ r_q = r_q.permute(2, 0, 1, 3, 4, 5).reshape(q_t, B * n_head * q_h * q_w, dim)
+ # [q_t, B*H*q_h*q_w, dim] * [q_t, dim, k_t] = [q_t, B*H*q_h*q_w, k_t] -> [B*H*q_h*q_w, q_t, k_t]
+ rel_q_t = torch.matmul(r_q, Rt.transpose(1, 2)).transpose(0, 1)
+ # [B*H*q_h*q_w, q_t, k_t] -> [B, H, q_t, q_h, q_w, k_t]
+ rel_q_t = rel_q_t.view(B, n_head, q_h, q_w, q_t, k_t).permute(0, 1, 4, 2, 3, 5)
+
+ # Combine rel pos.
+ rel_pos = (
+ rel_h_q[:, :, :, :, :, None, :, None]
+ + rel_w_q[:, :, :, :, :, None, None, :]
+ + rel_q_t[:, :, :, :, :, :, None, None]
+ ).reshape(B, n_head, q_t * q_h * q_w, k_t * k_h * k_w)
+
+ # Add it to attention
+ attn[:, :, 1:, 1:] += rel_pos
+
+ return attn
+
+
+def _add_shortcut(x: torch.Tensor, shortcut: torch.Tensor, residual_with_cls_embed: bool):
+ if residual_with_cls_embed:
+ x.add_(shortcut)
+ else:
+ x[:, :, 1:, :] += shortcut[:, :, 1:, :]
+ return x
+
+
+torch.fx.wrap("_add_rel_pos")
+torch.fx.wrap("_add_shortcut")
+
+
+class MultiscaleAttention(nn.Module):
+ def __init__(
+ self,
+ input_size: List[int],
+ embed_dim: int,
+ output_dim: int,
+ num_heads: int,
+ kernel_q: List[int],
+ kernel_kv: List[int],
+ stride_q: List[int],
+ stride_kv: List[int],
+ residual_pool: bool,
+ residual_with_cls_embed: bool,
+ rel_pos_embed: bool,
+ dropout: float = 0.0,
+ norm_layer: Callable[..., nn.Module] = nn.LayerNorm,
+ ) -> None:
+ super().__init__()
+ self.embed_dim = embed_dim
+ self.output_dim = output_dim
+ self.num_heads = num_heads
+ self.head_dim = output_dim // num_heads
+ self.scaler = 1.0 / math.sqrt(self.head_dim)
+ self.residual_pool = residual_pool
+ self.residual_with_cls_embed = residual_with_cls_embed
+
+ self.qkv = nn.Linear(embed_dim, 3 * output_dim)
+ layers: List[nn.Module] = [nn.Linear(output_dim, output_dim)]
+ if dropout > 0.0:
+ layers.append(nn.Dropout(dropout, inplace=True))
+ self.project = nn.Sequential(*layers)
+
+ self.pool_q: Optional[nn.Module] = None
+ if _prod(kernel_q) > 1 or _prod(stride_q) > 1:
+ padding_q = [int(q // 2) for q in kernel_q]
+ self.pool_q = Pool(
+ nn.Conv3d(
+ self.head_dim,
+ self.head_dim,
+ kernel_q, # type: ignore[arg-type]
+ stride=stride_q, # type: ignore[arg-type]
+ padding=padding_q, # type: ignore[arg-type]
+ groups=self.head_dim,
+ bias=False,
+ ),
+ norm_layer(self.head_dim),
+ )
+
+ self.pool_k: Optional[nn.Module] = None
+ self.pool_v: Optional[nn.Module] = None
+ if _prod(kernel_kv) > 1 or _prod(stride_kv) > 1:
+ padding_kv = [int(kv // 2) for kv in kernel_kv]
+ self.pool_k = Pool(
+ nn.Conv3d(
+ self.head_dim,
+ self.head_dim,
+ kernel_kv, # type: ignore[arg-type]
+ stride=stride_kv, # type: ignore[arg-type]
+ padding=padding_kv, # type: ignore[arg-type]
+ groups=self.head_dim,
+ bias=False,
+ ),
+ norm_layer(self.head_dim),
+ )
+ self.pool_v = Pool(
+ nn.Conv3d(
+ self.head_dim,
+ self.head_dim,
+ kernel_kv, # type: ignore[arg-type]
+ stride=stride_kv, # type: ignore[arg-type]
+ padding=padding_kv, # type: ignore[arg-type]
+ groups=self.head_dim,
+ bias=False,
+ ),
+ norm_layer(self.head_dim),
+ )
+
+ self.rel_pos_h: Optional[nn.Parameter] = None
+ self.rel_pos_w: Optional[nn.Parameter] = None
+ self.rel_pos_t: Optional[nn.Parameter] = None
+ if rel_pos_embed:
+ size = max(input_size[1:])
+ q_size = size // stride_q[1] if len(stride_q) > 0 else size
+ kv_size = size // stride_kv[1] if len(stride_kv) > 0 else size
+ spatial_dim = 2 * max(q_size, kv_size) - 1
+ temporal_dim = 2 * input_size[0] - 1
+ self.rel_pos_h = nn.Parameter(torch.zeros(spatial_dim, self.head_dim))
+ self.rel_pos_w = nn.Parameter(torch.zeros(spatial_dim, self.head_dim))
+ self.rel_pos_t = nn.Parameter(torch.zeros(temporal_dim, self.head_dim))
+ nn.init.trunc_normal_(self.rel_pos_h, std=0.02)
+ nn.init.trunc_normal_(self.rel_pos_w, std=0.02)
+ nn.init.trunc_normal_(self.rel_pos_t, std=0.02)
+
+ def forward(self, x: torch.Tensor, thw: Tuple[int, int, int]) -> Tuple[torch.Tensor, Tuple[int, int, int]]:
+ B, N, C = x.shape
+ q, k, v = self.qkv(x).reshape(B, N, 3, self.num_heads, self.head_dim).transpose(1, 3).unbind(dim=2)
+
+ if self.pool_k is not None:
+ k, k_thw = self.pool_k(k, thw)
+ else:
+ k_thw = thw
+ if self.pool_v is not None:
+ v = self.pool_v(v, thw)[0]
+ if self.pool_q is not None:
+ q, thw = self.pool_q(q, thw)
+
+ attn = torch.matmul(self.scaler * q, k.transpose(2, 3))
+ if self.rel_pos_h is not None and self.rel_pos_w is not None and self.rel_pos_t is not None:
+ attn = _add_rel_pos(
+ attn,
+ q,
+ thw,
+ k_thw,
+ self.rel_pos_h,
+ self.rel_pos_w,
+ self.rel_pos_t,
+ )
+ attn = attn.softmax(dim=-1)
+
+ x = torch.matmul(attn, v)
+ if self.residual_pool:
+ _add_shortcut(x, q, self.residual_with_cls_embed)
+ x = x.transpose(1, 2).reshape(B, -1, self.output_dim)
+ x = self.project(x)
+
+ return x, thw
+
+
+class MultiscaleBlock(nn.Module):
+ def __init__(
+ self,
+ input_size: List[int],
+ cnf: MSBlockConfig,
+ residual_pool: bool,
+ residual_with_cls_embed: bool,
+ rel_pos_embed: bool,
+ proj_after_attn: bool,
+ dropout: float = 0.0,
+ stochastic_depth_prob: float = 0.0,
+ norm_layer: Callable[..., nn.Module] = nn.LayerNorm,
+ ) -> None:
+ super().__init__()
+ self.proj_after_attn = proj_after_attn
+
+ self.pool_skip: Optional[nn.Module] = None
+ if _prod(cnf.stride_q) > 1:
+ kernel_skip = [s + 1 if s > 1 else s for s in cnf.stride_q]
+ padding_skip = [int(k // 2) for k in kernel_skip]
+ self.pool_skip = Pool(
+ nn.MaxPool3d(kernel_skip, stride=cnf.stride_q, padding=padding_skip), None # type: ignore[arg-type]
+ )
+
+ attn_dim = cnf.output_channels if proj_after_attn else cnf.input_channels
+
+ self.norm1 = norm_layer(cnf.input_channels)
+ self.norm2 = norm_layer(attn_dim)
+ self.needs_transposal = isinstance(self.norm1, nn.BatchNorm1d)
+
+ self.attn = MultiscaleAttention(
+ input_size,
+ cnf.input_channels,
+ attn_dim,
+ cnf.num_heads,
+ kernel_q=cnf.kernel_q,
+ kernel_kv=cnf.kernel_kv,
+ stride_q=cnf.stride_q,
+ stride_kv=cnf.stride_kv,
+ rel_pos_embed=rel_pos_embed,
+ residual_pool=residual_pool,
+ residual_with_cls_embed=residual_with_cls_embed,
+ dropout=dropout,
+ norm_layer=norm_layer,
+ )
+ self.mlp = MLP(
+ attn_dim,
+ [4 * attn_dim, cnf.output_channels],
+ activation_layer=nn.GELU,
+ dropout=dropout,
+ inplace=None,
+ )
+
+ self.stochastic_depth = StochasticDepth(stochastic_depth_prob, "row")
+
+ self.project: Optional[nn.Module] = None
+ if cnf.input_channels != cnf.output_channels:
+ self.project = nn.Linear(cnf.input_channels, cnf.output_channels)
+
+ def forward(self, x: torch.Tensor, thw: Tuple[int, int, int]) -> Tuple[torch.Tensor, Tuple[int, int, int]]:
+ x_norm1 = self.norm1(x.transpose(1, 2)).transpose(1, 2) if self.needs_transposal else self.norm1(x)
+ x_attn, thw_new = self.attn(x_norm1, thw)
+ x = x if self.project is None or not self.proj_after_attn else self.project(x_norm1)
+ x_skip = x if self.pool_skip is None else self.pool_skip(x, thw)[0]
+ x = x_skip + self.stochastic_depth(x_attn)
+
+ x_norm2 = self.norm2(x.transpose(1, 2)).transpose(1, 2) if self.needs_transposal else self.norm2(x)
+ x_proj = x if self.project is None or self.proj_after_attn else self.project(x_norm2)
+
+ return x_proj + self.stochastic_depth(self.mlp(x_norm2)), thw_new
+
+
+class PositionalEncoding(nn.Module):
+ def __init__(self, embed_size: int, spatial_size: Tuple[int, int], temporal_size: int, rel_pos_embed: bool) -> None:
+ super().__init__()
+ self.spatial_size = spatial_size
+ self.temporal_size = temporal_size
+
+ self.class_token = nn.Parameter(torch.zeros(embed_size))
+ self.spatial_pos: Optional[nn.Parameter] = None
+ self.temporal_pos: Optional[nn.Parameter] = None
+ self.class_pos: Optional[nn.Parameter] = None
+ if not rel_pos_embed:
+ self.spatial_pos = nn.Parameter(torch.zeros(self.spatial_size[0] * self.spatial_size[1], embed_size))
+ self.temporal_pos = nn.Parameter(torch.zeros(self.temporal_size, embed_size))
+ self.class_pos = nn.Parameter(torch.zeros(embed_size))
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ class_token = self.class_token.expand(x.size(0), -1).unsqueeze(1)
+ x = torch.cat((class_token, x), dim=1)
+
+ if self.spatial_pos is not None and self.temporal_pos is not None and self.class_pos is not None:
+ hw_size, embed_size = self.spatial_pos.shape
+ pos_embedding = torch.repeat_interleave(self.temporal_pos, hw_size, dim=0)
+ pos_embedding.add_(self.spatial_pos.unsqueeze(0).expand(self.temporal_size, -1, -1).reshape(-1, embed_size))
+ pos_embedding = torch.cat((self.class_pos.unsqueeze(0), pos_embedding), dim=0).unsqueeze(0)
+ x.add_(pos_embedding)
+
+ return x
+
+
+class MViT(nn.Module):
+ def __init__(
+ self,
+ spatial_size: Tuple[int, int],
+ temporal_size: int,
+ block_setting: Sequence[MSBlockConfig],
+ residual_pool: bool,
+ residual_with_cls_embed: bool,
+ rel_pos_embed: bool,
+ proj_after_attn: bool,
+ dropout: float = 0.5,
+ attention_dropout: float = 0.0,
+ stochastic_depth_prob: float = 0.0,
+ num_classes: int = 400,
+ block: Optional[Callable[..., nn.Module]] = None,
+ norm_layer: Optional[Callable[..., nn.Module]] = None,
+ patch_embed_kernel: Tuple[int, int, int] = (3, 7, 7),
+ patch_embed_stride: Tuple[int, int, int] = (2, 4, 4),
+ patch_embed_padding: Tuple[int, int, int] = (1, 3, 3),
+ ) -> None:
+ """
+ MViT main class.
+
+ Args:
+ spatial_size (tuple of ints): The spacial size of the input as ``(H, W)``.
+ temporal_size (int): The temporal size ``T`` of the input.
+ block_setting (sequence of MSBlockConfig): The Network structure.
+ residual_pool (bool): If True, use MViTv2 pooling residual connection.
+ residual_with_cls_embed (bool): If True, the addition on the residual connection will include
+ the class embedding.
+ rel_pos_embed (bool): If True, use MViTv2's relative positional embeddings.
+ proj_after_attn (bool): If True, apply the projection after the attention.
+ dropout (float): Dropout rate. Default: 0.0.
+ attention_dropout (float): Attention dropout rate. Default: 0.0.
+ stochastic_depth_prob: (float): Stochastic depth rate. Default: 0.0.
+ num_classes (int): The number of classes.
+ block (callable, optional): Module specifying the layer which consists of the attention and mlp.
+ norm_layer (callable, optional): Module specifying the normalization layer to use.
+ patch_embed_kernel (tuple of ints): The kernel of the convolution that patchifies the input.
+ patch_embed_stride (tuple of ints): The stride of the convolution that patchifies the input.
+ patch_embed_padding (tuple of ints): The padding of the convolution that patchifies the input.
+ """
+ super().__init__()
+ # This implementation employs a different parameterization scheme than the one used at PyTorch Video:
+ # https://github.com/facebookresearch/pytorchvideo/blob/718d0a4/pytorchvideo/models/vision_transformers.py
+ # We remove any experimental configuration that didn't make it to the final variants of the models. To represent
+ # the configuration of the architecture we use the simplified form suggested at Table 1 of the paper.
+ _log_api_usage_once(self)
+ total_stage_blocks = len(block_setting)
+ if total_stage_blocks == 0:
+ raise ValueError("The configuration parameter can't be empty.")
+
+ if block is None:
+ block = MultiscaleBlock
+
+ if norm_layer is None:
+ norm_layer = partial(nn.LayerNorm, eps=1e-6)
+
+ # Patch Embedding module
+ self.conv_proj = nn.Conv3d(
+ in_channels=3,
+ out_channels=block_setting[0].input_channels,
+ kernel_size=patch_embed_kernel,
+ stride=patch_embed_stride,
+ padding=patch_embed_padding,
+ )
+
+ input_size = [size // stride for size, stride in zip((temporal_size,) + spatial_size, self.conv_proj.stride)]
+
+ # Spatio-Temporal Class Positional Encoding
+ self.pos_encoding = PositionalEncoding(
+ embed_size=block_setting[0].input_channels,
+ spatial_size=(input_size[1], input_size[2]),
+ temporal_size=input_size[0],
+ rel_pos_embed=rel_pos_embed,
+ )
+
+ # Encoder module
+ self.blocks = nn.ModuleList()
+ for stage_block_id, cnf in enumerate(block_setting):
+ # adjust stochastic depth probability based on the depth of the stage block
+ sd_prob = stochastic_depth_prob * stage_block_id / (total_stage_blocks - 1.0)
+
+ self.blocks.append(
+ block(
+ input_size=input_size,
+ cnf=cnf,
+ residual_pool=residual_pool,
+ residual_with_cls_embed=residual_with_cls_embed,
+ rel_pos_embed=rel_pos_embed,
+ proj_after_attn=proj_after_attn,
+ dropout=attention_dropout,
+ stochastic_depth_prob=sd_prob,
+ norm_layer=norm_layer,
+ )
+ )
+
+ if len(cnf.stride_q) > 0:
+ input_size = [size // stride for size, stride in zip(input_size, cnf.stride_q)]
+ self.norm = norm_layer(block_setting[-1].output_channels)
+
+ # Classifier module
+ self.head = nn.Sequential(
+ nn.Dropout(dropout, inplace=True),
+ nn.Linear(block_setting[-1].output_channels, num_classes),
+ )
+
+ for m in self.modules():
+ if isinstance(m, nn.Linear):
+ nn.init.trunc_normal_(m.weight, std=0.02)
+ if isinstance(m, nn.Linear) and m.bias is not None:
+ nn.init.constant_(m.bias, 0.0)
+ elif isinstance(m, nn.LayerNorm):
+ if m.weight is not None:
+ nn.init.constant_(m.weight, 1.0)
+ if m.bias is not None:
+ nn.init.constant_(m.bias, 0.0)
+ elif isinstance(m, PositionalEncoding):
+ for weights in m.parameters():
+ nn.init.trunc_normal_(weights, std=0.02)
+
+ def forward(self, x: torch.Tensor) -> torch.Tensor:
+ # Convert if necessary (B, C, H, W) -> (B, C, 1, H, W)
+ x = _unsqueeze(x, 5, 2)[0]
+ # patchify and reshape: (B, C, T, H, W) -> (B, embed_channels[0], T', H', W') -> (B, THW', embed_channels[0])
+ x = self.conv_proj(x)
+ x = x.flatten(2).transpose(1, 2)
+
+ # add positional encoding
+ x = self.pos_encoding(x)
+
+ # pass patches through the encoder
+ thw = (self.pos_encoding.temporal_size,) + self.pos_encoding.spatial_size
+ for block in self.blocks:
+ x, thw = block(x, thw)
+ x = self.norm(x)
+
+ # classifier "token" as used by standard language architectures
+ x = x[:, 0]
+ x = self.head(x)
+
+ return x
+
+
+def _mvit(
+ block_setting: List[MSBlockConfig],
+ stochastic_depth_prob: float,
+ weights: Optional[WeightsEnum],
+ progress: bool,
+ **kwargs: Any,
+) -> MViT:
+ if weights is not None:
+ _ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"]))
+ assert weights.meta["min_size"][0] == weights.meta["min_size"][1]
+ _ovewrite_named_param(kwargs, "spatial_size", weights.meta["min_size"])
+ _ovewrite_named_param(kwargs, "temporal_size", weights.meta["min_temporal_size"])
+ spatial_size = kwargs.pop("spatial_size", (224, 224))
+ temporal_size = kwargs.pop("temporal_size", 16)
+
+ model = MViT(
+ spatial_size=spatial_size,
+ temporal_size=temporal_size,
+ block_setting=block_setting,
+ residual_pool=kwargs.pop("residual_pool", False),
+ residual_with_cls_embed=kwargs.pop("residual_with_cls_embed", True),
+ rel_pos_embed=kwargs.pop("rel_pos_embed", False),
+ proj_after_attn=kwargs.pop("proj_after_attn", False),
+ stochastic_depth_prob=stochastic_depth_prob,
+ **kwargs,
+ )
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
+
+
+class MViT_V1_B_Weights(WeightsEnum):
+ KINETICS400_V1 = Weights(
+ url="https://download.pytorch.org/models/mvit_v1_b-dbeb1030.pth",
+ transforms=partial(
+ VideoClassification,
+ crop_size=(224, 224),
+ resize_size=(256,),
+ mean=(0.45, 0.45, 0.45),
+ std=(0.225, 0.225, 0.225),
+ ),
+ meta={
+ "min_size": (224, 224),
+ "min_temporal_size": 16,
+ "categories": _KINETICS400_CATEGORIES,
+ "recipe": "https://github.com/facebookresearch/pytorchvideo/blob/main/docs/source/model_zoo.md",
+ "_docs": (
+ "The weights were ported from the paper. The accuracies are estimated on video-level "
+ "with parameters `frame_rate=7.5`, `clips_per_video=5`, and `clip_len=16`"
+ ),
+ "num_params": 36610672,
+ "_metrics": {
+ "Kinetics-400": {
+ "acc@1": 78.477,
+ "acc@5": 93.582,
+ }
+ },
+ "_ops": 70.599,
+ "_file_size": 139.764,
+ },
+ )
+ DEFAULT = KINETICS400_V1
+
+
+class MViT_V2_S_Weights(WeightsEnum):
+ KINETICS400_V1 = Weights(
+ url="https://download.pytorch.org/models/mvit_v2_s-ae3be167.pth",
+ transforms=partial(
+ VideoClassification,
+ crop_size=(224, 224),
+ resize_size=(256,),
+ mean=(0.45, 0.45, 0.45),
+ std=(0.225, 0.225, 0.225),
+ ),
+ meta={
+ "min_size": (224, 224),
+ "min_temporal_size": 16,
+ "categories": _KINETICS400_CATEGORIES,
+ "recipe": "https://github.com/facebookresearch/SlowFast/blob/main/MODEL_ZOO.md",
+ "_docs": (
+ "The weights were ported from the paper. The accuracies are estimated on video-level "
+ "with parameters `frame_rate=7.5`, `clips_per_video=5`, and `clip_len=16`"
+ ),
+ "num_params": 34537744,
+ "_metrics": {
+ "Kinetics-400": {
+ "acc@1": 80.757,
+ "acc@5": 94.665,
+ }
+ },
+ "_ops": 64.224,
+ "_file_size": 131.884,
+ },
+ )
+ DEFAULT = KINETICS400_V1
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", MViT_V1_B_Weights.KINETICS400_V1))
+def mvit_v1_b(*, weights: Optional[MViT_V1_B_Weights] = None, progress: bool = True, **kwargs: Any) -> MViT:
+ """
+ Constructs a base MViTV1 architecture from
+ `Multiscale Vision Transformers `__.
+
+ .. betastatus:: video module
+
+ Args:
+ weights (:class:`~torchvision.models.video.MViT_V1_B_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.video.MViT_V1_B_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.video.MViT``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.video.MViT_V1_B_Weights
+ :members:
+ """
+ weights = MViT_V1_B_Weights.verify(weights)
+
+ config: Dict[str, List] = {
+ "num_heads": [1, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8],
+ "input_channels": [96, 192, 192, 384, 384, 384, 384, 384, 384, 384, 384, 384, 384, 384, 768, 768],
+ "output_channels": [192, 192, 384, 384, 384, 384, 384, 384, 384, 384, 384, 384, 384, 768, 768, 768],
+ "kernel_q": [[], [3, 3, 3], [], [3, 3, 3], [], [], [], [], [], [], [], [], [], [], [3, 3, 3], []],
+ "kernel_kv": [
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ ],
+ "stride_q": [[], [1, 2, 2], [], [1, 2, 2], [], [], [], [], [], [], [], [], [], [], [1, 2, 2], []],
+ "stride_kv": [
+ [1, 8, 8],
+ [1, 4, 4],
+ [1, 4, 4],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 1, 1],
+ [1, 1, 1],
+ ],
+ }
+
+ block_setting = []
+ for i in range(len(config["num_heads"])):
+ block_setting.append(
+ MSBlockConfig(
+ num_heads=config["num_heads"][i],
+ input_channels=config["input_channels"][i],
+ output_channels=config["output_channels"][i],
+ kernel_q=config["kernel_q"][i],
+ kernel_kv=config["kernel_kv"][i],
+ stride_q=config["stride_q"][i],
+ stride_kv=config["stride_kv"][i],
+ )
+ )
+
+ return _mvit(
+ spatial_size=(224, 224),
+ temporal_size=16,
+ block_setting=block_setting,
+ residual_pool=False,
+ residual_with_cls_embed=False,
+ stochastic_depth_prob=kwargs.pop("stochastic_depth_prob", 0.2),
+ weights=weights,
+ progress=progress,
+ **kwargs,
+ )
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", MViT_V2_S_Weights.KINETICS400_V1))
+def mvit_v2_s(*, weights: Optional[MViT_V2_S_Weights] = None, progress: bool = True, **kwargs: Any) -> MViT:
+ """
+ Constructs a small MViTV2 architecture from
+ `Multiscale Vision Transformers `__.
+
+ .. betastatus:: video module
+
+ Args:
+ weights (:class:`~torchvision.models.video.MViT_V2_S_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.video.MViT_V2_S_Weights` below for
+ more details, and possible values. By default, no pre-trained
+ weights are used.
+ progress (bool, optional): If True, displays a progress bar of the
+ download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.video.MViT``
+ base class. Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.video.MViT_V2_S_Weights
+ :members:
+ """
+ weights = MViT_V2_S_Weights.verify(weights)
+
+ config: Dict[str, List] = {
+ "num_heads": [1, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8],
+ "input_channels": [96, 96, 192, 192, 384, 384, 384, 384, 384, 384, 384, 384, 384, 384, 384, 768],
+ "output_channels": [96, 192, 192, 384, 384, 384, 384, 384, 384, 384, 384, 384, 384, 384, 768, 768],
+ "kernel_q": [
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ ],
+ "kernel_kv": [
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ [3, 3, 3],
+ ],
+ "stride_q": [
+ [1, 1, 1],
+ [1, 2, 2],
+ [1, 1, 1],
+ [1, 2, 2],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 1, 1],
+ [1, 2, 2],
+ [1, 1, 1],
+ ],
+ "stride_kv": [
+ [1, 8, 8],
+ [1, 4, 4],
+ [1, 4, 4],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 2, 2],
+ [1, 1, 1],
+ [1, 1, 1],
+ ],
+ }
+
+ block_setting = []
+ for i in range(len(config["num_heads"])):
+ block_setting.append(
+ MSBlockConfig(
+ num_heads=config["num_heads"][i],
+ input_channels=config["input_channels"][i],
+ output_channels=config["output_channels"][i],
+ kernel_q=config["kernel_q"][i],
+ kernel_kv=config["kernel_kv"][i],
+ stride_q=config["stride_q"][i],
+ stride_kv=config["stride_kv"][i],
+ )
+ )
+
+ return _mvit(
+ spatial_size=(224, 224),
+ temporal_size=16,
+ block_setting=block_setting,
+ residual_pool=True,
+ residual_with_cls_embed=False,
+ rel_pos_embed=True,
+ proj_after_attn=True,
+ stochastic_depth_prob=kwargs.pop("stochastic_depth_prob", 0.2),
+ weights=weights,
+ progress=progress,
+ **kwargs,
+ )
diff --git a/wemm/lib/python3.10/site-packages/torchvision/models/video/s3d.py b/wemm/lib/python3.10/site-packages/torchvision/models/video/s3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..8716a454b26427ddfa5d51a996e0061a18e34e59
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/models/video/s3d.py
@@ -0,0 +1,219 @@
+from functools import partial
+from typing import Any, Callable, Optional
+
+import torch
+from torch import nn
+from torchvision.ops.misc import Conv3dNormActivation
+
+from ...transforms._presets import VideoClassification
+from ...utils import _log_api_usage_once
+from .._api import register_model, Weights, WeightsEnum
+from .._meta import _KINETICS400_CATEGORIES
+from .._utils import _ovewrite_named_param, handle_legacy_interface
+
+
+__all__ = [
+ "S3D",
+ "S3D_Weights",
+ "s3d",
+]
+
+
+class TemporalSeparableConv(nn.Sequential):
+ def __init__(
+ self,
+ in_planes: int,
+ out_planes: int,
+ kernel_size: int,
+ stride: int,
+ padding: int,
+ norm_layer: Callable[..., nn.Module],
+ ):
+ super().__init__(
+ Conv3dNormActivation(
+ in_planes,
+ out_planes,
+ kernel_size=(1, kernel_size, kernel_size),
+ stride=(1, stride, stride),
+ padding=(0, padding, padding),
+ bias=False,
+ norm_layer=norm_layer,
+ ),
+ Conv3dNormActivation(
+ out_planes,
+ out_planes,
+ kernel_size=(kernel_size, 1, 1),
+ stride=(stride, 1, 1),
+ padding=(padding, 0, 0),
+ bias=False,
+ norm_layer=norm_layer,
+ ),
+ )
+
+
+class SepInceptionBlock3D(nn.Module):
+ def __init__(
+ self,
+ in_planes: int,
+ b0_out: int,
+ b1_mid: int,
+ b1_out: int,
+ b2_mid: int,
+ b2_out: int,
+ b3_out: int,
+ norm_layer: Callable[..., nn.Module],
+ ):
+ super().__init__()
+
+ self.branch0 = Conv3dNormActivation(in_planes, b0_out, kernel_size=1, stride=1, norm_layer=norm_layer)
+ self.branch1 = nn.Sequential(
+ Conv3dNormActivation(in_planes, b1_mid, kernel_size=1, stride=1, norm_layer=norm_layer),
+ TemporalSeparableConv(b1_mid, b1_out, kernel_size=3, stride=1, padding=1, norm_layer=norm_layer),
+ )
+ self.branch2 = nn.Sequential(
+ Conv3dNormActivation(in_planes, b2_mid, kernel_size=1, stride=1, norm_layer=norm_layer),
+ TemporalSeparableConv(b2_mid, b2_out, kernel_size=3, stride=1, padding=1, norm_layer=norm_layer),
+ )
+ self.branch3 = nn.Sequential(
+ nn.MaxPool3d(kernel_size=(3, 3, 3), stride=1, padding=1),
+ Conv3dNormActivation(in_planes, b3_out, kernel_size=1, stride=1, norm_layer=norm_layer),
+ )
+
+ def forward(self, x):
+ x0 = self.branch0(x)
+ x1 = self.branch1(x)
+ x2 = self.branch2(x)
+ x3 = self.branch3(x)
+ out = torch.cat((x0, x1, x2, x3), 1)
+
+ return out
+
+
+class S3D(nn.Module):
+ """S3D main class.
+
+ Args:
+ num_class (int): number of classes for the classification task.
+ dropout (float): dropout probability.
+ norm_layer (Optional[Callable]): Module specifying the normalization layer to use.
+
+ Inputs:
+ x (Tensor): batch of videos with dimensions (batch, channel, time, height, width)
+ """
+
+ def __init__(
+ self,
+ num_classes: int = 400,
+ dropout: float = 0.2,
+ norm_layer: Optional[Callable[..., torch.nn.Module]] = None,
+ ) -> None:
+ super().__init__()
+ _log_api_usage_once(self)
+
+ if norm_layer is None:
+ norm_layer = partial(nn.BatchNorm3d, eps=0.001, momentum=0.001)
+
+ self.features = nn.Sequential(
+ TemporalSeparableConv(3, 64, 7, 2, 3, norm_layer),
+ nn.MaxPool3d(kernel_size=(1, 3, 3), stride=(1, 2, 2), padding=(0, 1, 1)),
+ Conv3dNormActivation(
+ 64,
+ 64,
+ kernel_size=1,
+ stride=1,
+ norm_layer=norm_layer,
+ ),
+ TemporalSeparableConv(64, 192, 3, 1, 1, norm_layer),
+ nn.MaxPool3d(kernel_size=(1, 3, 3), stride=(1, 2, 2), padding=(0, 1, 1)),
+ SepInceptionBlock3D(192, 64, 96, 128, 16, 32, 32, norm_layer),
+ SepInceptionBlock3D(256, 128, 128, 192, 32, 96, 64, norm_layer),
+ nn.MaxPool3d(kernel_size=(3, 3, 3), stride=(2, 2, 2), padding=(1, 1, 1)),
+ SepInceptionBlock3D(480, 192, 96, 208, 16, 48, 64, norm_layer),
+ SepInceptionBlock3D(512, 160, 112, 224, 24, 64, 64, norm_layer),
+ SepInceptionBlock3D(512, 128, 128, 256, 24, 64, 64, norm_layer),
+ SepInceptionBlock3D(512, 112, 144, 288, 32, 64, 64, norm_layer),
+ SepInceptionBlock3D(528, 256, 160, 320, 32, 128, 128, norm_layer),
+ nn.MaxPool3d(kernel_size=(2, 2, 2), stride=(2, 2, 2), padding=(0, 0, 0)),
+ SepInceptionBlock3D(832, 256, 160, 320, 32, 128, 128, norm_layer),
+ SepInceptionBlock3D(832, 384, 192, 384, 48, 128, 128, norm_layer),
+ )
+ self.avgpool = nn.AvgPool3d(kernel_size=(2, 7, 7), stride=1)
+ self.classifier = nn.Sequential(
+ nn.Dropout(p=dropout),
+ nn.Conv3d(1024, num_classes, kernel_size=1, stride=1, bias=True),
+ )
+
+ def forward(self, x):
+ x = self.features(x)
+ x = self.avgpool(x)
+ x = self.classifier(x)
+ x = torch.mean(x, dim=(2, 3, 4))
+ return x
+
+
+class S3D_Weights(WeightsEnum):
+ KINETICS400_V1 = Weights(
+ url="https://download.pytorch.org/models/s3d-d76dad2f.pth",
+ transforms=partial(
+ VideoClassification,
+ crop_size=(224, 224),
+ resize_size=(256, 256),
+ ),
+ meta={
+ "min_size": (224, 224),
+ "min_temporal_size": 14,
+ "categories": _KINETICS400_CATEGORIES,
+ "recipe": "https://github.com/pytorch/vision/tree/main/references/video_classification#s3d",
+ "_docs": (
+ "The weights aim to approximate the accuracy of the paper. The accuracies are estimated on clip-level "
+ "with parameters `frame_rate=15`, `clips_per_video=1`, and `clip_len=128`."
+ ),
+ "num_params": 8320048,
+ "_metrics": {
+ "Kinetics-400": {
+ "acc@1": 68.368,
+ "acc@5": 88.050,
+ }
+ },
+ "_ops": 17.979,
+ "_file_size": 31.972,
+ },
+ )
+ DEFAULT = KINETICS400_V1
+
+
+@register_model()
+@handle_legacy_interface(weights=("pretrained", S3D_Weights.KINETICS400_V1))
+def s3d(*, weights: Optional[S3D_Weights] = None, progress: bool = True, **kwargs: Any) -> S3D:
+ """Construct Separable 3D CNN model.
+
+ Reference: `Rethinking Spatiotemporal Feature Learning `__.
+
+ .. betastatus:: video module
+
+ Args:
+ weights (:class:`~torchvision.models.video.S3D_Weights`, optional): The
+ pretrained weights to use. See
+ :class:`~torchvision.models.video.S3D_Weights`
+ below for more details, and possible values. By default, no
+ pre-trained weights are used.
+ progress (bool): If True, displays a progress bar of the download to stderr. Default is True.
+ **kwargs: parameters passed to the ``torchvision.models.video.S3D`` base class.
+ Please refer to the `source code
+ `_
+ for more details about this class.
+
+ .. autoclass:: torchvision.models.video.S3D_Weights
+ :members:
+ """
+ weights = S3D_Weights.verify(weights)
+
+ if weights is not None:
+ _ovewrite_named_param(kwargs, "num_classes", len(weights.meta["categories"]))
+
+ model = S3D(**kwargs)
+
+ if weights is not None:
+ model.load_state_dict(weights.get_state_dict(progress=progress))
+
+ return model
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/__init__.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/__init__.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..3a93f115ea056c0e0cdf80c027bedfc4043071c6
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/__init__.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/_utils.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/_utils.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..06ade4167d869ccc5b7c0b125730cd47c6ed4ece
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/_utils.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/ciou_loss.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/ciou_loss.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..ede19fe8163a546c0277dae418d1fe3963bc0371
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/ciou_loss.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/ps_roi_pool.cpython-310.pyc b/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/ps_roi_pool.cpython-310.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..f77827ba58ff722541f0d05d07f357ca945365b4
Binary files /dev/null and b/wemm/lib/python3.10/site-packages/torchvision/ops/__pycache__/ps_roi_pool.cpython-310.pyc differ
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/_register_onnx_ops.py b/wemm/lib/python3.10/site-packages/torchvision/ops/_register_onnx_ops.py
new file mode 100644
index 0000000000000000000000000000000000000000..5dd263a5d8ef497becc4aa39252a93c913b84880
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/ops/_register_onnx_ops.py
@@ -0,0 +1,107 @@
+import sys
+import warnings
+
+import torch
+from torch.onnx import symbolic_opset11 as opset11
+from torch.onnx.symbolic_helper import parse_args
+
+_ONNX_OPSET_VERSION_11 = 11
+_ONNX_OPSET_VERSION_16 = 16
+BASE_ONNX_OPSET_VERSION = _ONNX_OPSET_VERSION_11
+
+
+@parse_args("v", "v", "f")
+def symbolic_multi_label_nms(g, boxes, scores, iou_threshold):
+ boxes = opset11.unsqueeze(g, boxes, 0)
+ scores = opset11.unsqueeze(g, opset11.unsqueeze(g, scores, 0), 0)
+ max_output_per_class = g.op("Constant", value_t=torch.tensor([sys.maxsize], dtype=torch.long))
+ iou_threshold = g.op("Constant", value_t=torch.tensor([iou_threshold], dtype=torch.float))
+
+ # Cast boxes and scores to float32 in case they are float64 inputs
+ nms_out = g.op(
+ "NonMaxSuppression",
+ g.op("Cast", boxes, to_i=torch.onnx.TensorProtoDataType.FLOAT),
+ g.op("Cast", scores, to_i=torch.onnx.TensorProtoDataType.FLOAT),
+ max_output_per_class,
+ iou_threshold,
+ )
+ return opset11.squeeze(
+ g, opset11.select(g, nms_out, 1, g.op("Constant", value_t=torch.tensor([2], dtype=torch.long))), 1
+ )
+
+
+def _process_batch_indices_for_roi_align(g, rois):
+ indices = opset11.squeeze(
+ g, opset11.select(g, rois, 1, g.op("Constant", value_t=torch.tensor([0], dtype=torch.long))), 1
+ )
+ return g.op("Cast", indices, to_i=torch.onnx.TensorProtoDataType.INT64)
+
+
+def _process_rois_for_roi_align(g, rois):
+ return opset11.select(g, rois, 1, g.op("Constant", value_t=torch.tensor([1, 2, 3, 4], dtype=torch.long)))
+
+
+def _process_sampling_ratio_for_roi_align(g, sampling_ratio: int):
+ if sampling_ratio < 0:
+ warnings.warn(
+ "ONNX export for RoIAlign with a non-zero sampling_ratio is not supported. "
+ "The model will be exported with a sampling_ratio of 0."
+ )
+ sampling_ratio = 0
+ return sampling_ratio
+
+
+@parse_args("v", "v", "f", "i", "i", "i", "i")
+def roi_align_opset11(g, input, rois, spatial_scale, pooled_height, pooled_width, sampling_ratio, aligned):
+ batch_indices = _process_batch_indices_for_roi_align(g, rois)
+ rois = _process_rois_for_roi_align(g, rois)
+ if aligned:
+ warnings.warn(
+ "ROIAlign with aligned=True is only supported in opset >= 16. "
+ "Please export with opset 16 or higher, or use aligned=False."
+ )
+ sampling_ratio = _process_sampling_ratio_for_roi_align(g, sampling_ratio)
+ return g.op(
+ "RoiAlign",
+ input,
+ rois,
+ batch_indices,
+ spatial_scale_f=spatial_scale,
+ output_height_i=pooled_height,
+ output_width_i=pooled_width,
+ sampling_ratio_i=sampling_ratio,
+ )
+
+
+@parse_args("v", "v", "f", "i", "i", "i", "i")
+def roi_align_opset16(g, input, rois, spatial_scale, pooled_height, pooled_width, sampling_ratio, aligned):
+ batch_indices = _process_batch_indices_for_roi_align(g, rois)
+ rois = _process_rois_for_roi_align(g, rois)
+ coordinate_transformation_mode = "half_pixel" if aligned else "output_half_pixel"
+ sampling_ratio = _process_sampling_ratio_for_roi_align(g, sampling_ratio)
+ return g.op(
+ "RoiAlign",
+ input,
+ rois,
+ batch_indices,
+ coordinate_transformation_mode_s=coordinate_transformation_mode,
+ spatial_scale_f=spatial_scale,
+ output_height_i=pooled_height,
+ output_width_i=pooled_width,
+ sampling_ratio_i=sampling_ratio,
+ )
+
+
+@parse_args("v", "v", "f", "i", "i")
+def roi_pool(g, input, rois, spatial_scale, pooled_height, pooled_width):
+ roi_pool = g.op(
+ "MaxRoiPool", input, rois, pooled_shape_i=(pooled_height, pooled_width), spatial_scale_f=spatial_scale
+ )
+ return roi_pool, None
+
+
+def _register_custom_op():
+ torch.onnx.register_custom_op_symbolic("torchvision::nms", symbolic_multi_label_nms, _ONNX_OPSET_VERSION_11)
+ torch.onnx.register_custom_op_symbolic("torchvision::roi_align", roi_align_opset11, _ONNX_OPSET_VERSION_11)
+ torch.onnx.register_custom_op_symbolic("torchvision::roi_align", roi_align_opset16, _ONNX_OPSET_VERSION_16)
+ torch.onnx.register_custom_op_symbolic("torchvision::roi_pool", roi_pool, _ONNX_OPSET_VERSION_11)
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/deform_conv.py b/wemm/lib/python3.10/site-packages/torchvision/ops/deform_conv.py
new file mode 100644
index 0000000000000000000000000000000000000000..bb4400e5c29c107ea945a410b2f1aeedf3c9b8d4
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/ops/deform_conv.py
@@ -0,0 +1,195 @@
+import math
+from typing import Optional, Tuple
+
+import torch
+from torch import nn, Tensor
+from torch.nn import init
+from torch.nn.modules.utils import _pair
+from torch.nn.parameter import Parameter
+from torchvision.extension import _assert_has_ops
+
+from ..utils import _log_api_usage_once
+
+
+def deform_conv2d(
+ input: Tensor,
+ offset: Tensor,
+ weight: Tensor,
+ bias: Optional[Tensor] = None,
+ stride: Tuple[int, int] = (1, 1),
+ padding: Tuple[int, int] = (0, 0),
+ dilation: Tuple[int, int] = (1, 1),
+ mask: Optional[Tensor] = None,
+) -> Tensor:
+ r"""
+ Performs Deformable Convolution v2, described in
+ `Deformable ConvNets v2: More Deformable, Better Results
+ `__ if :attr:`mask` is not ``None`` and
+ Performs Deformable Convolution, described in
+ `Deformable Convolutional Networks
+ `__ if :attr:`mask` is ``None``.
+
+ Args:
+ input (Tensor[batch_size, in_channels, in_height, in_width]): input tensor
+ offset (Tensor[batch_size, 2 * offset_groups * kernel_height * kernel_width, out_height, out_width]):
+ offsets to be applied for each position in the convolution kernel.
+ weight (Tensor[out_channels, in_channels // groups, kernel_height, kernel_width]): convolution weights,
+ split into groups of size (in_channels // groups)
+ bias (Tensor[out_channels]): optional bias of shape (out_channels,). Default: None
+ stride (int or Tuple[int, int]): distance between convolution centers. Default: 1
+ padding (int or Tuple[int, int]): height/width of padding of zeroes around
+ each image. Default: 0
+ dilation (int or Tuple[int, int]): the spacing between kernel elements. Default: 1
+ mask (Tensor[batch_size, offset_groups * kernel_height * kernel_width, out_height, out_width]):
+ masks to be applied for each position in the convolution kernel. Default: None
+
+ Returns:
+ Tensor[batch_sz, out_channels, out_h, out_w]: result of convolution
+
+ Examples::
+ >>> input = torch.rand(4, 3, 10, 10)
+ >>> kh, kw = 3, 3
+ >>> weight = torch.rand(5, 3, kh, kw)
+ >>> # offset and mask should have the same spatial size as the output
+ >>> # of the convolution. In this case, for an input of 10, stride of 1
+ >>> # and kernel size of 3, without padding, the output size is 8
+ >>> offset = torch.rand(4, 2 * kh * kw, 8, 8)
+ >>> mask = torch.rand(4, kh * kw, 8, 8)
+ >>> out = deform_conv2d(input, offset, weight, mask=mask)
+ >>> print(out.shape)
+ >>> # returns
+ >>> torch.Size([4, 5, 8, 8])
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(deform_conv2d)
+ _assert_has_ops()
+ out_channels = weight.shape[0]
+
+ use_mask = mask is not None
+
+ if mask is None:
+ mask = torch.zeros((input.shape[0], 0), device=input.device, dtype=input.dtype)
+
+ if bias is None:
+ bias = torch.zeros(out_channels, device=input.device, dtype=input.dtype)
+
+ stride_h, stride_w = _pair(stride)
+ pad_h, pad_w = _pair(padding)
+ dil_h, dil_w = _pair(dilation)
+ weights_h, weights_w = weight.shape[-2:]
+ _, n_in_channels, _, _ = input.shape
+
+ n_offset_grps = offset.shape[1] // (2 * weights_h * weights_w)
+ n_weight_grps = n_in_channels // weight.shape[1]
+
+ if n_offset_grps == 0:
+ raise RuntimeError(
+ "the shape of the offset tensor at dimension 1 is not valid. It should "
+ "be a multiple of 2 * weight.size[2] * weight.size[3].\n"
+ f"Got offset.shape[1]={offset.shape[1]}, while 2 * weight.size[2] * weight.size[3]={2 * weights_h * weights_w}"
+ )
+
+ return torch.ops.torchvision.deform_conv2d(
+ input,
+ weight,
+ offset,
+ mask,
+ bias,
+ stride_h,
+ stride_w,
+ pad_h,
+ pad_w,
+ dil_h,
+ dil_w,
+ n_weight_grps,
+ n_offset_grps,
+ use_mask,
+ )
+
+
+class DeformConv2d(nn.Module):
+ """
+ See :func:`deform_conv2d`.
+ """
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: int,
+ stride: int = 1,
+ padding: int = 0,
+ dilation: int = 1,
+ groups: int = 1,
+ bias: bool = True,
+ ):
+ super().__init__()
+ _log_api_usage_once(self)
+
+ if in_channels % groups != 0:
+ raise ValueError("in_channels must be divisible by groups")
+ if out_channels % groups != 0:
+ raise ValueError("out_channels must be divisible by groups")
+
+ self.in_channels = in_channels
+ self.out_channels = out_channels
+ self.kernel_size = _pair(kernel_size)
+ self.stride = _pair(stride)
+ self.padding = _pair(padding)
+ self.dilation = _pair(dilation)
+ self.groups = groups
+
+ self.weight = Parameter(
+ torch.empty(out_channels, in_channels // groups, self.kernel_size[0], self.kernel_size[1])
+ )
+
+ if bias:
+ self.bias = Parameter(torch.empty(out_channels))
+ else:
+ self.register_parameter("bias", None)
+
+ self.reset_parameters()
+
+ def reset_parameters(self) -> None:
+ init.kaiming_uniform_(self.weight, a=math.sqrt(5))
+
+ if self.bias is not None:
+ fan_in, _ = init._calculate_fan_in_and_fan_out(self.weight)
+ bound = 1 / math.sqrt(fan_in)
+ init.uniform_(self.bias, -bound, bound)
+
+ def forward(self, input: Tensor, offset: Tensor, mask: Optional[Tensor] = None) -> Tensor:
+ """
+ Args:
+ input (Tensor[batch_size, in_channels, in_height, in_width]): input tensor
+ offset (Tensor[batch_size, 2 * offset_groups * kernel_height * kernel_width, out_height, out_width]):
+ offsets to be applied for each position in the convolution kernel.
+ mask (Tensor[batch_size, offset_groups * kernel_height * kernel_width, out_height, out_width]):
+ masks to be applied for each position in the convolution kernel.
+ """
+ return deform_conv2d(
+ input,
+ offset,
+ self.weight,
+ self.bias,
+ stride=self.stride,
+ padding=self.padding,
+ dilation=self.dilation,
+ mask=mask,
+ )
+
+ def __repr__(self) -> str:
+ s = (
+ f"{self.__class__.__name__}("
+ f"{self.in_channels}"
+ f", {self.out_channels}"
+ f", kernel_size={self.kernel_size}"
+ f", stride={self.stride}"
+ )
+ s += f", padding={self.padding}" if self.padding != (0, 0) else ""
+ s += f", dilation={self.dilation}" if self.dilation != (1, 1) else ""
+ s += f", groups={self.groups}" if self.groups != 1 else ""
+ s += ", bias=False" if self.bias is None else ""
+ s += ")"
+
+ return s
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/focal_loss.py b/wemm/lib/python3.10/site-packages/torchvision/ops/focal_loss.py
new file mode 100644
index 0000000000000000000000000000000000000000..08c282555fca01cbee78d79c2a0fa7bb8a9df570
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/ops/focal_loss.py
@@ -0,0 +1,58 @@
+import torch
+import torch.nn.functional as F
+
+from ..utils import _log_api_usage_once
+
+
+def sigmoid_focal_loss(
+ inputs: torch.Tensor,
+ targets: torch.Tensor,
+ alpha: float = 0.25,
+ gamma: float = 2,
+ reduction: str = "none",
+) -> torch.Tensor:
+ """
+ Loss used in RetinaNet for dense detection: https://arxiv.org/abs/1708.02002.
+
+ Args:
+ inputs (Tensor): A float tensor of arbitrary shape.
+ The predictions for each example.
+ targets (Tensor): A float tensor with the same shape as inputs. Stores the binary
+ classification label for each element in inputs
+ (0 for the negative class and 1 for the positive class).
+ alpha (float): Weighting factor in range (0,1) to balance
+ positive vs negative examples or -1 for ignore. Default: ``0.25``.
+ gamma (float): Exponent of the modulating factor (1 - p_t) to
+ balance easy vs hard examples. Default: ``2``.
+ reduction (string): ``'none'`` | ``'mean'`` | ``'sum'``
+ ``'none'``: No reduction will be applied to the output.
+ ``'mean'``: The output will be averaged.
+ ``'sum'``: The output will be summed. Default: ``'none'``.
+ Returns:
+ Loss tensor with the reduction option applied.
+ """
+ # Original implementation from https://github.com/facebookresearch/fvcore/blob/master/fvcore/nn/focal_loss.py
+
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(sigmoid_focal_loss)
+ p = torch.sigmoid(inputs)
+ ce_loss = F.binary_cross_entropy_with_logits(inputs, targets, reduction="none")
+ p_t = p * targets + (1 - p) * (1 - targets)
+ loss = ce_loss * ((1 - p_t) ** gamma)
+
+ if alpha >= 0:
+ alpha_t = alpha * targets + (1 - alpha) * (1 - targets)
+ loss = alpha_t * loss
+
+ # Check reduction option and return loss accordingly
+ if reduction == "none":
+ pass
+ elif reduction == "mean":
+ loss = loss.mean()
+ elif reduction == "sum":
+ loss = loss.sum()
+ else:
+ raise ValueError(
+ f"Invalid Value for arg 'reduction': '{reduction} \n Supported reduction modes: 'none', 'mean', 'sum'"
+ )
+ return loss
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/giou_loss.py b/wemm/lib/python3.10/site-packages/torchvision/ops/giou_loss.py
new file mode 100644
index 0000000000000000000000000000000000000000..ec8bc8852fe71258cb5a46fdf5428581a23b4c3e
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/ops/giou_loss.py
@@ -0,0 +1,76 @@
+import torch
+
+from ..utils import _log_api_usage_once
+from ._utils import _loss_inter_union, _upcast_non_float
+
+
+def generalized_box_iou_loss(
+ boxes1: torch.Tensor,
+ boxes2: torch.Tensor,
+ reduction: str = "none",
+ eps: float = 1e-7,
+) -> torch.Tensor:
+
+ """
+ Gradient-friendly IoU loss with an additional penalty that is non-zero when the
+ boxes do not overlap and scales with the size of their smallest enclosing box.
+ This loss is symmetric, so the boxes1 and boxes2 arguments are interchangeable.
+
+ Both sets of boxes are expected to be in ``(x1, y1, x2, y2)`` format with
+ ``0 <= x1 < x2`` and ``0 <= y1 < y2``, and The two boxes should have the
+ same dimensions.
+
+ Args:
+ boxes1 (Tensor[N, 4] or Tensor[4]): first set of boxes
+ boxes2 (Tensor[N, 4] or Tensor[4]): second set of boxes
+ reduction (string, optional): Specifies the reduction to apply to the output:
+ ``'none'`` | ``'mean'`` | ``'sum'``. ``'none'``: No reduction will be
+ applied to the output. ``'mean'``: The output will be averaged.
+ ``'sum'``: The output will be summed. Default: ``'none'``
+ eps (float): small number to prevent division by zero. Default: 1e-7
+
+ Returns:
+ Tensor: Loss tensor with the reduction option applied.
+
+ Reference:
+ Hamid Rezatofighi et al.: Generalized Intersection over Union:
+ A Metric and A Loss for Bounding Box Regression:
+ https://arxiv.org/abs/1902.09630
+ """
+
+ # Original implementation from https://github.com/facebookresearch/fvcore/blob/bfff2ef/fvcore/nn/giou_loss.py
+
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(generalized_box_iou_loss)
+
+ boxes1 = _upcast_non_float(boxes1)
+ boxes2 = _upcast_non_float(boxes2)
+ intsctk, unionk = _loss_inter_union(boxes1, boxes2)
+ iouk = intsctk / (unionk + eps)
+
+ x1, y1, x2, y2 = boxes1.unbind(dim=-1)
+ x1g, y1g, x2g, y2g = boxes2.unbind(dim=-1)
+
+ # smallest enclosing box
+ xc1 = torch.min(x1, x1g)
+ yc1 = torch.min(y1, y1g)
+ xc2 = torch.max(x2, x2g)
+ yc2 = torch.max(y2, y2g)
+
+ area_c = (xc2 - xc1) * (yc2 - yc1)
+ miouk = iouk - ((area_c - unionk) / (area_c + eps))
+
+ loss = 1 - miouk
+
+ # Check reduction option and return loss accordingly
+ if reduction == "none":
+ pass
+ elif reduction == "mean":
+ loss = loss.mean() if loss.numel() > 0 else 0.0 * loss.sum()
+ elif reduction == "sum":
+ loss = loss.sum()
+ else:
+ raise ValueError(
+ f"Invalid Value for arg 'reduction': '{reduction} \n Supported reduction modes: 'none', 'mean', 'sum'"
+ )
+ return loss
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/misc.py b/wemm/lib/python3.10/site-packages/torchvision/ops/misc.py
new file mode 100644
index 0000000000000000000000000000000000000000..0bbea6bce43425dec79a655857a92b1f36883098
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/ops/misc.py
@@ -0,0 +1,320 @@
+import warnings
+from typing import Callable, List, Optional, Sequence, Tuple, Union
+
+import torch
+from torch import Tensor
+
+from ..utils import _log_api_usage_once, _make_ntuple
+
+
+interpolate = torch.nn.functional.interpolate
+
+
+class FrozenBatchNorm2d(torch.nn.Module):
+ """
+ BatchNorm2d where the batch statistics and the affine parameters are fixed
+
+ Args:
+ num_features (int): Number of features ``C`` from an expected input of size ``(N, C, H, W)``
+ eps (float): a value added to the denominator for numerical stability. Default: 1e-5
+ """
+
+ def __init__(
+ self,
+ num_features: int,
+ eps: float = 1e-5,
+ ):
+ super().__init__()
+ _log_api_usage_once(self)
+ self.eps = eps
+ self.register_buffer("weight", torch.ones(num_features))
+ self.register_buffer("bias", torch.zeros(num_features))
+ self.register_buffer("running_mean", torch.zeros(num_features))
+ self.register_buffer("running_var", torch.ones(num_features))
+
+ def _load_from_state_dict(
+ self,
+ state_dict: dict,
+ prefix: str,
+ local_metadata: dict,
+ strict: bool,
+ missing_keys: List[str],
+ unexpected_keys: List[str],
+ error_msgs: List[str],
+ ):
+ num_batches_tracked_key = prefix + "num_batches_tracked"
+ if num_batches_tracked_key in state_dict:
+ del state_dict[num_batches_tracked_key]
+
+ super()._load_from_state_dict(
+ state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs
+ )
+
+ def forward(self, x: Tensor) -> Tensor:
+ # move reshapes to the beginning
+ # to make it fuser-friendly
+ w = self.weight.reshape(1, -1, 1, 1)
+ b = self.bias.reshape(1, -1, 1, 1)
+ rv = self.running_var.reshape(1, -1, 1, 1)
+ rm = self.running_mean.reshape(1, -1, 1, 1)
+ scale = w * (rv + self.eps).rsqrt()
+ bias = b - rm * scale
+ return x * scale + bias
+
+ def __repr__(self) -> str:
+ return f"{self.__class__.__name__}({self.weight.shape[0]}, eps={self.eps})"
+
+
+class ConvNormActivation(torch.nn.Sequential):
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: Union[int, Tuple[int, ...]] = 3,
+ stride: Union[int, Tuple[int, ...]] = 1,
+ padding: Optional[Union[int, Tuple[int, ...], str]] = None,
+ groups: int = 1,
+ norm_layer: Optional[Callable[..., torch.nn.Module]] = torch.nn.BatchNorm2d,
+ activation_layer: Optional[Callable[..., torch.nn.Module]] = torch.nn.ReLU,
+ dilation: Union[int, Tuple[int, ...]] = 1,
+ inplace: Optional[bool] = True,
+ bias: Optional[bool] = None,
+ conv_layer: Callable[..., torch.nn.Module] = torch.nn.Conv2d,
+ ) -> None:
+
+ if padding is None:
+ if isinstance(kernel_size, int) and isinstance(dilation, int):
+ padding = (kernel_size - 1) // 2 * dilation
+ else:
+ _conv_dim = len(kernel_size) if isinstance(kernel_size, Sequence) else len(dilation)
+ kernel_size = _make_ntuple(kernel_size, _conv_dim)
+ dilation = _make_ntuple(dilation, _conv_dim)
+ padding = tuple((kernel_size[i] - 1) // 2 * dilation[i] for i in range(_conv_dim))
+ if bias is None:
+ bias = norm_layer is None
+
+ layers = [
+ conv_layer(
+ in_channels,
+ out_channels,
+ kernel_size,
+ stride,
+ padding,
+ dilation=dilation,
+ groups=groups,
+ bias=bias,
+ )
+ ]
+
+ if norm_layer is not None:
+ layers.append(norm_layer(out_channels))
+
+ if activation_layer is not None:
+ params = {} if inplace is None else {"inplace": inplace}
+ layers.append(activation_layer(**params))
+ super().__init__(*layers)
+ _log_api_usage_once(self)
+ self.out_channels = out_channels
+
+ if self.__class__ == ConvNormActivation:
+ warnings.warn(
+ "Don't use ConvNormActivation directly, please use Conv2dNormActivation and Conv3dNormActivation instead."
+ )
+
+
+class Conv2dNormActivation(ConvNormActivation):
+ """
+ Configurable block used for Convolution2d-Normalization-Activation blocks.
+
+ Args:
+ in_channels (int): Number of channels in the input image
+ out_channels (int): Number of channels produced by the Convolution-Normalization-Activation block
+ kernel_size: (int, optional): Size of the convolving kernel. Default: 3
+ stride (int, optional): Stride of the convolution. Default: 1
+ padding (int, tuple or str, optional): Padding added to all four sides of the input. Default: None, in which case it will be calculated as ``padding = (kernel_size - 1) // 2 * dilation``
+ groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1
+ norm_layer (Callable[..., torch.nn.Module], optional): Norm layer that will be stacked on top of the convolution layer. If ``None`` this layer won't be used. Default: ``torch.nn.BatchNorm2d``
+ activation_layer (Callable[..., torch.nn.Module], optional): Activation function which will be stacked on top of the normalization layer (if not None), otherwise on top of the conv layer. If ``None`` this layer won't be used. Default: ``torch.nn.ReLU``
+ dilation (int): Spacing between kernel elements. Default: 1
+ inplace (bool): Parameter for the activation layer, which can optionally do the operation in-place. Default ``True``
+ bias (bool, optional): Whether to use bias in the convolution layer. By default, biases are included if ``norm_layer is None``.
+
+ """
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: Union[int, Tuple[int, int]] = 3,
+ stride: Union[int, Tuple[int, int]] = 1,
+ padding: Optional[Union[int, Tuple[int, int], str]] = None,
+ groups: int = 1,
+ norm_layer: Optional[Callable[..., torch.nn.Module]] = torch.nn.BatchNorm2d,
+ activation_layer: Optional[Callable[..., torch.nn.Module]] = torch.nn.ReLU,
+ dilation: Union[int, Tuple[int, int]] = 1,
+ inplace: Optional[bool] = True,
+ bias: Optional[bool] = None,
+ ) -> None:
+
+ super().__init__(
+ in_channels,
+ out_channels,
+ kernel_size,
+ stride,
+ padding,
+ groups,
+ norm_layer,
+ activation_layer,
+ dilation,
+ inplace,
+ bias,
+ torch.nn.Conv2d,
+ )
+
+
+class Conv3dNormActivation(ConvNormActivation):
+ """
+ Configurable block used for Convolution3d-Normalization-Activation blocks.
+
+ Args:
+ in_channels (int): Number of channels in the input video.
+ out_channels (int): Number of channels produced by the Convolution-Normalization-Activation block
+ kernel_size: (int, optional): Size of the convolving kernel. Default: 3
+ stride (int, optional): Stride of the convolution. Default: 1
+ padding (int, tuple or str, optional): Padding added to all four sides of the input. Default: None, in which case it will be calculated as ``padding = (kernel_size - 1) // 2 * dilation``
+ groups (int, optional): Number of blocked connections from input channels to output channels. Default: 1
+ norm_layer (Callable[..., torch.nn.Module], optional): Norm layer that will be stacked on top of the convolution layer. If ``None`` this layer won't be used. Default: ``torch.nn.BatchNorm3d``
+ activation_layer (Callable[..., torch.nn.Module], optional): Activation function which will be stacked on top of the normalization layer (if not None), otherwise on top of the conv layer. If ``None`` this layer won't be used. Default: ``torch.nn.ReLU``
+ dilation (int): Spacing between kernel elements. Default: 1
+ inplace (bool): Parameter for the activation layer, which can optionally do the operation in-place. Default ``True``
+ bias (bool, optional): Whether to use bias in the convolution layer. By default, biases are included if ``norm_layer is None``.
+ """
+
+ def __init__(
+ self,
+ in_channels: int,
+ out_channels: int,
+ kernel_size: Union[int, Tuple[int, int, int]] = 3,
+ stride: Union[int, Tuple[int, int, int]] = 1,
+ padding: Optional[Union[int, Tuple[int, int, int], str]] = None,
+ groups: int = 1,
+ norm_layer: Optional[Callable[..., torch.nn.Module]] = torch.nn.BatchNorm3d,
+ activation_layer: Optional[Callable[..., torch.nn.Module]] = torch.nn.ReLU,
+ dilation: Union[int, Tuple[int, int, int]] = 1,
+ inplace: Optional[bool] = True,
+ bias: Optional[bool] = None,
+ ) -> None:
+
+ super().__init__(
+ in_channels,
+ out_channels,
+ kernel_size,
+ stride,
+ padding,
+ groups,
+ norm_layer,
+ activation_layer,
+ dilation,
+ inplace,
+ bias,
+ torch.nn.Conv3d,
+ )
+
+
+class SqueezeExcitation(torch.nn.Module):
+ """
+ This block implements the Squeeze-and-Excitation block from https://arxiv.org/abs/1709.01507 (see Fig. 1).
+ Parameters ``activation``, and ``scale_activation`` correspond to ``delta`` and ``sigma`` in eq. 3.
+
+ Args:
+ input_channels (int): Number of channels in the input image
+ squeeze_channels (int): Number of squeeze channels
+ activation (Callable[..., torch.nn.Module], optional): ``delta`` activation. Default: ``torch.nn.ReLU``
+ scale_activation (Callable[..., torch.nn.Module]): ``sigma`` activation. Default: ``torch.nn.Sigmoid``
+ """
+
+ def __init__(
+ self,
+ input_channels: int,
+ squeeze_channels: int,
+ activation: Callable[..., torch.nn.Module] = torch.nn.ReLU,
+ scale_activation: Callable[..., torch.nn.Module] = torch.nn.Sigmoid,
+ ) -> None:
+ super().__init__()
+ _log_api_usage_once(self)
+ self.avgpool = torch.nn.AdaptiveAvgPool2d(1)
+ self.fc1 = torch.nn.Conv2d(input_channels, squeeze_channels, 1)
+ self.fc2 = torch.nn.Conv2d(squeeze_channels, input_channels, 1)
+ self.activation = activation()
+ self.scale_activation = scale_activation()
+
+ def _scale(self, input: Tensor) -> Tensor:
+ scale = self.avgpool(input)
+ scale = self.fc1(scale)
+ scale = self.activation(scale)
+ scale = self.fc2(scale)
+ return self.scale_activation(scale)
+
+ def forward(self, input: Tensor) -> Tensor:
+ scale = self._scale(input)
+ return scale * input
+
+
+class MLP(torch.nn.Sequential):
+ """This block implements the multi-layer perceptron (MLP) module.
+
+ Args:
+ in_channels (int): Number of channels of the input
+ hidden_channels (List[int]): List of the hidden channel dimensions
+ norm_layer (Callable[..., torch.nn.Module], optional): Norm layer that will be stacked on top of the linear layer. If ``None`` this layer won't be used. Default: ``None``
+ activation_layer (Callable[..., torch.nn.Module], optional): Activation function which will be stacked on top of the normalization layer (if not None), otherwise on top of the linear layer. If ``None`` this layer won't be used. Default: ``torch.nn.ReLU``
+ inplace (bool, optional): Parameter for the activation layer, which can optionally do the operation in-place.
+ Default is ``None``, which uses the respective default values of the ``activation_layer`` and Dropout layer.
+ bias (bool): Whether to use bias in the linear layer. Default ``True``
+ dropout (float): The probability for the dropout layer. Default: 0.0
+ """
+
+ def __init__(
+ self,
+ in_channels: int,
+ hidden_channels: List[int],
+ norm_layer: Optional[Callable[..., torch.nn.Module]] = None,
+ activation_layer: Optional[Callable[..., torch.nn.Module]] = torch.nn.ReLU,
+ inplace: Optional[bool] = None,
+ bias: bool = True,
+ dropout: float = 0.0,
+ ):
+ # The addition of `norm_layer` is inspired from the implementation of TorchMultimodal:
+ # https://github.com/facebookresearch/multimodal/blob/5dec8a/torchmultimodal/modules/layers/mlp.py
+ params = {} if inplace is None else {"inplace": inplace}
+
+ layers = []
+ in_dim = in_channels
+ for hidden_dim in hidden_channels[:-1]:
+ layers.append(torch.nn.Linear(in_dim, hidden_dim, bias=bias))
+ if norm_layer is not None:
+ layers.append(norm_layer(hidden_dim))
+ layers.append(activation_layer(**params))
+ layers.append(torch.nn.Dropout(dropout, **params))
+ in_dim = hidden_dim
+
+ layers.append(torch.nn.Linear(in_dim, hidden_channels[-1], bias=bias))
+ layers.append(torch.nn.Dropout(dropout, **params))
+
+ super().__init__(*layers)
+ _log_api_usage_once(self)
+
+
+class Permute(torch.nn.Module):
+ """This module returns a view of the tensor input with its dimensions permuted.
+
+ Args:
+ dims (List[int]): The desired ordering of dimensions
+ """
+
+ def __init__(self, dims: List[int]):
+ super().__init__()
+ self.dims = dims
+
+ def forward(self, x: Tensor) -> Tensor:
+ return torch.permute(x, self.dims)
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/poolers.py b/wemm/lib/python3.10/site-packages/torchvision/ops/poolers.py
new file mode 100644
index 0000000000000000000000000000000000000000..9cdd83a598bea0a044179269f8369b58401801d1
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/ops/poolers.py
@@ -0,0 +1,327 @@
+from typing import Dict, List, Optional, Tuple, Union
+
+import torch
+import torch.fx
+import torchvision
+from torch import nn, Tensor
+from torchvision.ops.boxes import box_area
+
+from ..utils import _log_api_usage_once
+from .roi_align import roi_align
+
+
+# copying result_idx_in_level to a specific index in result[]
+# is not supported by ONNX tracing yet.
+# _onnx_merge_levels() is an implementation supported by ONNX
+# that merges the levels to the right indices
+@torch.jit.unused
+def _onnx_merge_levels(levels: Tensor, unmerged_results: List[Tensor]) -> Tensor:
+ first_result = unmerged_results[0]
+ dtype, device = first_result.dtype, first_result.device
+ res = torch.zeros(
+ (levels.size(0), first_result.size(1), first_result.size(2), first_result.size(3)), dtype=dtype, device=device
+ )
+ for level in range(len(unmerged_results)):
+ index = torch.where(levels == level)[0].view(-1, 1, 1, 1)
+ index = index.expand(
+ index.size(0),
+ unmerged_results[level].size(1),
+ unmerged_results[level].size(2),
+ unmerged_results[level].size(3),
+ )
+ res = res.scatter(0, index, unmerged_results[level])
+ return res
+
+
+# TODO: (eellison) T54974082 https://github.com/pytorch/pytorch/issues/26744/pytorch/issues/26744
+def initLevelMapper(
+ k_min: int,
+ k_max: int,
+ canonical_scale: int = 224,
+ canonical_level: int = 4,
+ eps: float = 1e-6,
+):
+ return LevelMapper(k_min, k_max, canonical_scale, canonical_level, eps)
+
+
+class LevelMapper:
+ """Determine which FPN level each RoI in a set of RoIs should map to based
+ on the heuristic in the FPN paper.
+
+ Args:
+ k_min (int)
+ k_max (int)
+ canonical_scale (int)
+ canonical_level (int)
+ eps (float)
+ """
+
+ def __init__(
+ self,
+ k_min: int,
+ k_max: int,
+ canonical_scale: int = 224,
+ canonical_level: int = 4,
+ eps: float = 1e-6,
+ ):
+ self.k_min = k_min
+ self.k_max = k_max
+ self.s0 = canonical_scale
+ self.lvl0 = canonical_level
+ self.eps = eps
+
+ def __call__(self, boxlists: List[Tensor]) -> Tensor:
+ """
+ Args:
+ boxlists (list[BoxList])
+ """
+ # Compute level ids
+ s = torch.sqrt(torch.cat([box_area(boxlist) for boxlist in boxlists]))
+
+ # Eqn.(1) in FPN paper
+ target_lvls = torch.floor(self.lvl0 + torch.log2(s / self.s0) + torch.tensor(self.eps, dtype=s.dtype))
+ target_lvls = torch.clamp(target_lvls, min=self.k_min, max=self.k_max)
+ return (target_lvls.to(torch.int64) - self.k_min).to(torch.int64)
+
+
+def _convert_to_roi_format(boxes: List[Tensor]) -> Tensor:
+ concat_boxes = torch.cat(boxes, dim=0)
+ device, dtype = concat_boxes.device, concat_boxes.dtype
+ ids = torch.cat(
+ [torch.full_like(b[:, :1], i, dtype=dtype, layout=torch.strided, device=device) for i, b in enumerate(boxes)],
+ dim=0,
+ )
+ rois = torch.cat([ids, concat_boxes], dim=1)
+ return rois
+
+
+def _infer_scale(feature: Tensor, original_size: List[int]) -> float:
+ # assumption: the scale is of the form 2 ** (-k), with k integer
+ size = feature.shape[-2:]
+ possible_scales: List[float] = []
+ for s1, s2 in zip(size, original_size):
+ approx_scale = float(s1) / float(s2)
+ scale = 2 ** float(torch.tensor(approx_scale).log2().round())
+ possible_scales.append(scale)
+ return possible_scales[0]
+
+
+@torch.fx.wrap
+def _setup_scales(
+ features: List[Tensor], image_shapes: List[Tuple[int, int]], canonical_scale: int, canonical_level: int
+) -> Tuple[List[float], LevelMapper]:
+ if not image_shapes:
+ raise ValueError("images list should not be empty")
+ max_x = 0
+ max_y = 0
+ for shape in image_shapes:
+ max_x = max(shape[0], max_x)
+ max_y = max(shape[1], max_y)
+ original_input_shape = (max_x, max_y)
+
+ scales = [_infer_scale(feat, original_input_shape) for feat in features]
+ # get the levels in the feature map by leveraging the fact that the network always
+ # downsamples by a factor of 2 at each level.
+ lvl_min = -torch.log2(torch.tensor(scales[0], dtype=torch.float32)).item()
+ lvl_max = -torch.log2(torch.tensor(scales[-1], dtype=torch.float32)).item()
+
+ map_levels = initLevelMapper(
+ int(lvl_min),
+ int(lvl_max),
+ canonical_scale=canonical_scale,
+ canonical_level=canonical_level,
+ )
+ return scales, map_levels
+
+
+@torch.fx.wrap
+def _filter_input(x: Dict[str, Tensor], featmap_names: List[str]) -> List[Tensor]:
+ x_filtered = []
+ for k, v in x.items():
+ if k in featmap_names:
+ x_filtered.append(v)
+ return x_filtered
+
+
+@torch.fx.wrap
+def _multiscale_roi_align(
+ x_filtered: List[Tensor],
+ boxes: List[Tensor],
+ output_size: List[int],
+ sampling_ratio: int,
+ scales: Optional[List[float]],
+ mapper: Optional[LevelMapper],
+) -> Tensor:
+ """
+ Args:
+ x_filtered (List[Tensor]): List of input tensors.
+ boxes (List[Tensor[N, 4]]): boxes to be used to perform the pooling operation, in
+ (x1, y1, x2, y2) format and in the image reference size, not the feature map
+ reference. The coordinate must satisfy ``0 <= x1 < x2`` and ``0 <= y1 < y2``.
+ output_size (Union[List[Tuple[int, int]], List[int]]): size of the output
+ sampling_ratio (int): sampling ratio for ROIAlign
+ scales (Optional[List[float]]): If None, scales will be automatically inferred. Default value is None.
+ mapper (Optional[LevelMapper]): If none, mapper will be automatically inferred. Default value is None.
+ Returns:
+ result (Tensor)
+ """
+ if scales is None or mapper is None:
+ raise ValueError("scales and mapper should not be None")
+
+ num_levels = len(x_filtered)
+ rois = _convert_to_roi_format(boxes)
+
+ if num_levels == 1:
+ return roi_align(
+ x_filtered[0],
+ rois,
+ output_size=output_size,
+ spatial_scale=scales[0],
+ sampling_ratio=sampling_ratio,
+ )
+
+ levels = mapper(boxes)
+
+ num_rois = len(rois)
+ num_channels = x_filtered[0].shape[1]
+
+ dtype, device = x_filtered[0].dtype, x_filtered[0].device
+ result = torch.zeros(
+ (
+ num_rois,
+ num_channels,
+ )
+ + output_size,
+ dtype=dtype,
+ device=device,
+ )
+
+ tracing_results = []
+ for level, (per_level_feature, scale) in enumerate(zip(x_filtered, scales)):
+ idx_in_level = torch.where(levels == level)[0]
+ rois_per_level = rois[idx_in_level]
+
+ result_idx_in_level = roi_align(
+ per_level_feature,
+ rois_per_level,
+ output_size=output_size,
+ spatial_scale=scale,
+ sampling_ratio=sampling_ratio,
+ )
+
+ if torchvision._is_tracing():
+ tracing_results.append(result_idx_in_level.to(dtype))
+ else:
+ # result and result_idx_in_level's dtypes are based on dtypes of different
+ # elements in x_filtered. x_filtered contains tensors output by different
+ # layers. When autocast is active, it may choose different dtypes for
+ # different layers' outputs. Therefore, we defensively match result's dtype
+ # before copying elements from result_idx_in_level in the following op.
+ # We need to cast manually (can't rely on autocast to cast for us) because
+ # the op acts on result in-place, and autocast only affects out-of-place ops.
+ result[idx_in_level] = result_idx_in_level.to(result.dtype)
+
+ if torchvision._is_tracing():
+ result = _onnx_merge_levels(levels, tracing_results)
+
+ return result
+
+
+class MultiScaleRoIAlign(nn.Module):
+ """
+ Multi-scale RoIAlign pooling, which is useful for detection with or without FPN.
+
+ It infers the scale of the pooling via the heuristics specified in eq. 1
+ of the `Feature Pyramid Network paper `_.
+ They keyword-only parameters ``canonical_scale`` and ``canonical_level``
+ correspond respectively to ``224`` and ``k0=4`` in eq. 1, and
+ have the following meaning: ``canonical_level`` is the target level of the pyramid from
+ which to pool a region of interest with ``w x h = canonical_scale x canonical_scale``.
+
+ Args:
+ featmap_names (List[str]): the names of the feature maps that will be used
+ for the pooling.
+ output_size (List[Tuple[int, int]] or List[int]): output size for the pooled region
+ sampling_ratio (int): sampling ratio for ROIAlign
+ canonical_scale (int, optional): canonical_scale for LevelMapper
+ canonical_level (int, optional): canonical_level for LevelMapper
+
+ Examples::
+
+ >>> m = torchvision.ops.MultiScaleRoIAlign(['feat1', 'feat3'], 3, 2)
+ >>> i = OrderedDict()
+ >>> i['feat1'] = torch.rand(1, 5, 64, 64)
+ >>> i['feat2'] = torch.rand(1, 5, 32, 32) # this feature won't be used in the pooling
+ >>> i['feat3'] = torch.rand(1, 5, 16, 16)
+ >>> # create some random bounding boxes
+ >>> boxes = torch.rand(6, 4) * 256; boxes[:, 2:] += boxes[:, :2]
+ >>> # original image size, before computing the feature maps
+ >>> image_sizes = [(512, 512)]
+ >>> output = m(i, [boxes], image_sizes)
+ >>> print(output.shape)
+ >>> torch.Size([6, 5, 3, 3])
+
+ """
+
+ __annotations__ = {"scales": Optional[List[float]], "map_levels": Optional[LevelMapper]}
+
+ def __init__(
+ self,
+ featmap_names: List[str],
+ output_size: Union[int, Tuple[int], List[int]],
+ sampling_ratio: int,
+ *,
+ canonical_scale: int = 224,
+ canonical_level: int = 4,
+ ):
+ super().__init__()
+ _log_api_usage_once(self)
+ if isinstance(output_size, int):
+ output_size = (output_size, output_size)
+ self.featmap_names = featmap_names
+ self.sampling_ratio = sampling_ratio
+ self.output_size = tuple(output_size)
+ self.scales = None
+ self.map_levels = None
+ self.canonical_scale = canonical_scale
+ self.canonical_level = canonical_level
+
+ def forward(
+ self,
+ x: Dict[str, Tensor],
+ boxes: List[Tensor],
+ image_shapes: List[Tuple[int, int]],
+ ) -> Tensor:
+ """
+ Args:
+ x (OrderedDict[Tensor]): feature maps for each level. They are assumed to have
+ all the same number of channels, but they can have different sizes.
+ boxes (List[Tensor[N, 4]]): boxes to be used to perform the pooling operation, in
+ (x1, y1, x2, y2) format and in the image reference size, not the feature map
+ reference. The coordinate must satisfy ``0 <= x1 < x2`` and ``0 <= y1 < y2``.
+ image_shapes (List[Tuple[height, width]]): the sizes of each image before they
+ have been fed to a CNN to obtain feature maps. This allows us to infer the
+ scale factor for each one of the levels to be pooled.
+ Returns:
+ result (Tensor)
+ """
+ x_filtered = _filter_input(x, self.featmap_names)
+ if self.scales is None or self.map_levels is None:
+ self.scales, self.map_levels = _setup_scales(
+ x_filtered, image_shapes, self.canonical_scale, self.canonical_level
+ )
+
+ return _multiscale_roi_align(
+ x_filtered,
+ boxes,
+ self.output_size,
+ self.sampling_ratio,
+ self.scales,
+ self.map_levels,
+ )
+
+ def __repr__(self) -> str:
+ return (
+ f"{self.__class__.__name__}(featmap_names={self.featmap_names}, "
+ f"output_size={self.output_size}, sampling_ratio={self.sampling_ratio})"
+ )
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/ps_roi_align.py b/wemm/lib/python3.10/site-packages/torchvision/ops/ps_roi_align.py
new file mode 100644
index 0000000000000000000000000000000000000000..82809b8f8885667b28eccd22aca60d1dca02f3bf
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/ops/ps_roi_align.py
@@ -0,0 +1,90 @@
+import torch
+import torch.fx
+from torch import nn, Tensor
+from torch.nn.modules.utils import _pair
+from torchvision.extension import _assert_has_ops
+
+from ..utils import _log_api_usage_once
+from ._utils import check_roi_boxes_shape, convert_boxes_to_roi_format
+
+
+@torch.fx.wrap
+def ps_roi_align(
+ input: Tensor,
+ boxes: Tensor,
+ output_size: int,
+ spatial_scale: float = 1.0,
+ sampling_ratio: int = -1,
+) -> Tensor:
+ """
+ Performs Position-Sensitive Region of Interest (RoI) Align operator
+ mentioned in Light-Head R-CNN.
+
+ Args:
+ input (Tensor[N, C, H, W]): The input tensor, i.e. a batch with ``N`` elements. Each element
+ contains ``C`` feature maps of dimensions ``H x W``.
+ boxes (Tensor[K, 5] or List[Tensor[L, 4]]): the box coordinates in (x1, y1, x2, y2)
+ format where the regions will be taken from.
+ The coordinate must satisfy ``0 <= x1 < x2`` and ``0 <= y1 < y2``.
+ If a single Tensor is passed, then the first column should
+ contain the index of the corresponding element in the batch, i.e. a number in ``[0, N - 1]``.
+ If a list of Tensors is passed, then each Tensor will correspond to the boxes for an element i
+ in the batch.
+ output_size (int or Tuple[int, int]): the size of the output (in bins or pixels) after the pooling
+ is performed, as (height, width).
+ spatial_scale (float): a scaling factor that maps the box coordinates to
+ the input coordinates. For example, if your boxes are defined on the scale
+ of a 224x224 image and your input is a 112x112 feature map (resulting from a 0.5x scaling of
+ the original image), you'll want to set this to 0.5. Default: 1.0
+ sampling_ratio (int): number of sampling points in the interpolation grid
+ used to compute the output value of each pooled output bin. If > 0,
+ then exactly ``sampling_ratio x sampling_ratio`` sampling points per bin are used. If
+ <= 0, then an adaptive number of grid points are used (computed as
+ ``ceil(roi_width / output_width)``, and likewise for height). Default: -1
+
+ Returns:
+ Tensor[K, C / (output_size[0] * output_size[1]), output_size[0], output_size[1]]: The pooled RoIs
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(ps_roi_align)
+ _assert_has_ops()
+ check_roi_boxes_shape(boxes)
+ rois = boxes
+ output_size = _pair(output_size)
+ if not isinstance(rois, torch.Tensor):
+ rois = convert_boxes_to_roi_format(rois)
+ output, _ = torch.ops.torchvision.ps_roi_align(
+ input, rois, spatial_scale, output_size[0], output_size[1], sampling_ratio
+ )
+ return output
+
+
+class PSRoIAlign(nn.Module):
+ """
+ See :func:`ps_roi_align`.
+ """
+
+ def __init__(
+ self,
+ output_size: int,
+ spatial_scale: float,
+ sampling_ratio: int,
+ ):
+ super().__init__()
+ _log_api_usage_once(self)
+ self.output_size = output_size
+ self.spatial_scale = spatial_scale
+ self.sampling_ratio = sampling_ratio
+
+ def forward(self, input: Tensor, rois: Tensor) -> Tensor:
+ return ps_roi_align(input, rois, self.output_size, self.spatial_scale, self.sampling_ratio)
+
+ def __repr__(self) -> str:
+ s = (
+ f"{self.__class__.__name__}("
+ f"output_size={self.output_size}"
+ f", spatial_scale={self.spatial_scale}"
+ f", sampling_ratio={self.sampling_ratio}"
+ f")"
+ )
+ return s
diff --git a/wemm/lib/python3.10/site-packages/torchvision/ops/ps_roi_pool.py b/wemm/lib/python3.10/site-packages/torchvision/ops/ps_roi_pool.py
new file mode 100644
index 0000000000000000000000000000000000000000..15292dcad97490aaa740cdec2d0aedb31e5662eb
--- /dev/null
+++ b/wemm/lib/python3.10/site-packages/torchvision/ops/ps_roi_pool.py
@@ -0,0 +1,70 @@
+import torch
+import torch.fx
+from torch import nn, Tensor
+from torch.nn.modules.utils import _pair
+from torchvision.extension import _assert_has_ops
+
+from ..utils import _log_api_usage_once
+from ._utils import check_roi_boxes_shape, convert_boxes_to_roi_format
+
+
+@torch.fx.wrap
+def ps_roi_pool(
+ input: Tensor,
+ boxes: Tensor,
+ output_size: int,
+ spatial_scale: float = 1.0,
+) -> Tensor:
+ """
+ Performs Position-Sensitive Region of Interest (RoI) Pool operator
+ described in R-FCN
+
+ Args:
+ input (Tensor[N, C, H, W]): The input tensor, i.e. a batch with ``N`` elements. Each element
+ contains ``C`` feature maps of dimensions ``H x W``.
+ boxes (Tensor[K, 5] or List[Tensor[L, 4]]): the box coordinates in (x1, y1, x2, y2)
+ format where the regions will be taken from.
+ The coordinate must satisfy ``0 <= x1 < x2`` and ``0 <= y1 < y2``.
+ If a single Tensor is passed, then the first column should
+ contain the index of the corresponding element in the batch, i.e. a number in ``[0, N - 1]``.
+ If a list of Tensors is passed, then each Tensor will correspond to the boxes for an element i
+ in the batch.
+ output_size (int or Tuple[int, int]): the size of the output (in bins or pixels) after the pooling
+ is performed, as (height, width).
+ spatial_scale (float): a scaling factor that maps the box coordinates to
+ the input coordinates. For example, if your boxes are defined on the scale
+ of a 224x224 image and your input is a 112x112 feature map (resulting from a 0.5x scaling of
+ the original image), you'll want to set this to 0.5. Default: 1.0
+
+ Returns:
+ Tensor[K, C / (output_size[0] * output_size[1]), output_size[0], output_size[1]]: The pooled RoIs.
+ """
+ if not torch.jit.is_scripting() and not torch.jit.is_tracing():
+ _log_api_usage_once(ps_roi_pool)
+ _assert_has_ops()
+ check_roi_boxes_shape(boxes)
+ rois = boxes
+ output_size = _pair(output_size)
+ if not isinstance(rois, torch.Tensor):
+ rois = convert_boxes_to_roi_format(rois)
+ output, _ = torch.ops.torchvision.ps_roi_pool(input, rois, spatial_scale, output_size[0], output_size[1])
+ return output
+
+
+class PSRoIPool(nn.Module):
+ """
+ See :func:`ps_roi_pool`.
+ """
+
+ def __init__(self, output_size: int, spatial_scale: float):
+ super().__init__()
+ _log_api_usage_once(self)
+ self.output_size = output_size
+ self.spatial_scale = spatial_scale
+
+ def forward(self, input: Tensor, rois: Tensor) -> Tensor:
+ return ps_roi_pool(input, rois, self.output_size, self.spatial_scale)
+
+ def __repr__(self) -> str:
+ s = f"{self.__class__.__name__}(output_size={self.output_size}, spatial_scale={self.spatial_scale})"
+ return s