o .wiK!@sddlmZmZmZmZddlmZmZddlm Z ddl m Z m Z m Z mZddlmZddlmZes7dgZGdddeZd S) )AnyLiteralOptionalUnion)Tensornn)_LPIPS) GeneratorType*_perceptual_path_length_validate_arguments_validate_generator_modelperceptual_path_length)Metric)_TORCHVISION_AVAILABLEPerceptualPathLengthcseZdZUdZdZeed<dZeeed<dZ eed<e j ed<dZ e ed<    d&dededededdedeedeedeedee j edfdeddffdd Zd!eddfd"d#Zdeeeeffd$d%ZZS)'raComputes the perceptual path length (`PPL`_) of a generator model. The perceptual path length can be used to measure the consistency of interpolation in latent-space models. It is defined as .. math:: PPL = \mathbb{E}\left[\frac{1}{\epsilon^2} D(G(I(z_1, z_2, t)), G(I(z_1, z_2, t+\epsilon)))\right] where :math:`G` is the generator, :math:`I` is the interpolation function, :math:`D` is a similarity metric, :math:`z_1` and :math:`z_2` are two sets of latent points, and :math:`t` is a parameter between 0 and 1. The metric thus works by interpolating between two sets of latent points, and measuring the similarity between the generated images. The expectation is approximated by sampling :math:`z_1` and :math:`z_2` from the generator, and averaging the calculated distanced. The similarity metric :math:`D` is by default the `LPIPS`_ metric, but can be changed by setting the `sim_net` argument. The provided generator model must have a `sample` method with signature `sample(num_samples: int) -> Tensor` where the returned tensor has shape `(num_samples, z_size)`. If the generator is conditional, it must also have a `num_classes` attribute. The `forward` method of the generator must have signature `forward(z: Tensor) -> Tensor` if `conditional=False`, and `forward(z: Tensor, labels: Tensor) -> Tensor` if `conditional=True`. The returned tensor should have shape `(num_samples, C, H, W)` and be scaled to the range [0, 255]. .. hint:: Using this metric with the default feature extractor requires that ``torchvision`` is installed. Either install as ``pip install torchmetrics[image]`` or ``pip install torchvision`` As input to ``forward`` and ``update`` the metric accepts the following input - ``generator`` (:class:`~torch.nn.Module`): Generator model, with specific requirements. See above. As output of `forward` and `compute` the metric returns the following output - ``ppl_mean`` (:class:`~torch.Tensor`): float scalar tensor with mean PPL value over distances - ``ppl_std`` (:class:`~torch.Tensor`): float scalar tensor with std PPL value over distances - ``ppl_raw`` (:class:`~torch.Tensor`): float scalar tensor with raw PPL distances Args: num_samples: Number of samples to use for the PPL computation. conditional: Whether the generator is conditional or not (i.e. whether it takes labels as input). batch_size: Batch size to use for the PPL computation. interpolation_method: Interpolation method to use. Choose from 'lerp', 'slerp_any', 'slerp_unit'. epsilon: Spacing between the points on the path between latent points. resize: Resize images to this size before computing the similarity between generated images. lower_discard: Lower quantile to discard from the distances, before computing the mean and standard deviation. upper_discard: Upper quantile to discard from the distances, before computing the mean and standard deviation. sim_net: Similarity network to use. Can be a `nn.Module` or one of 'alex', 'vgg', 'squeeze', where the three latter options correspond to the pretrained networks from the `LPIPS`_ paper. kwargs: Additional keyword arguments, see :ref:`Metric kwargs` for more info. Raises: ModuleNotFoundError: If ``torch-fidelity`` is not installed. ValueError: If ``num_samples`` is not a positive integer. ValueError: If `conditional` is not a boolean. ValueError: If ``batch_size`` is not a positive integer. ValueError: If ``interpolation_method`` is not one of 'lerp', 'slerp_any', 'slerp_unit'. ValueError: If ``epsilon`` is not a positive float. ValueError: If ``resize`` is not a positive integer. ValueError: If ``lower_discard`` is not a float between 0 and 1 or None. ValueError: If ``upper_discard`` is not a float between 0 and 1 or None. Example:: >>> import torch >>> class DummyGenerator(torch.nn.Module): ... def __init__(self, z_size) -> None: ... super().__init__() ... self.z_size = z_size ... self.model = torch.nn.Sequential(torch.nn.Linear(z_size, 3*128*128), torch.nn.Sigmoid()) ... def forward(self, z): ... return 255 * (self.model(z).reshape(-1, 3, 128, 128) + 1) ... def sample(self, num_samples): ... return torch.randn(num_samples, self.z_size) >>> generator = DummyGenerator(2) >>> ppl = PerceptualPathLength(num_samples=10) >>> ppl(generator) (tensor(...), tensor(...), tensor([...])) Fis_differentiableThigher_is_betterfull_state_updatenetfeature_network'lerp-C6?@{Gz?Gz?vgg num_samples conditional batch_sizeinterpolation_method)r slerp_any slerp_unitepsilonresize lower_discard upper_discardsim_netalexrsqueezekwargsreturnNc stjdi| tstdt||||||||||_||_||_||_||_ ||_ ||_ ||_ t | tjr=| |_dS| dvrKtd| |d|_dStd| )NzMetric `PerceptualPathLength` requires torchvision which is not installed.Install with `pip install torchvision` or `pip install torchmetrics[image]`r(T) pretrainedrr$zDsim_net must be a nn.Module or one of 'alex', 'vgg', 'squeeze', got )super__init__rModuleNotFoundErrorr rrrr r#r$r%r& isinstancerModulerr ValueError) selfrrrr r#r$r%r&r'r+ __class__r.f/home/ubuntu/sommelier/.venv/lib/python3.10/site-packages/torchmetrics/image/perceptual_path_length.pyr0~s*   zPerceptualPathLength.__init__ generatorcCst||j||_dS)zUpdate the generator model.N)r rr9)r5r9r.r.r8updates  zPerceptualPathLength.updatec Cs0t|j|j|j|j|j|j|j|j|j |j d S)z#Compute the perceptual path length.) r9rrr r#r$r%r&r'device) r r9rrr r#r$r%r&rr;)r5r.r.r8computeszPerceptualPathLength.compute) rFrrrrrrr)__name__ __module__ __qualname____doc__rbool__annotations__rrrrr3rstrintrfloatrrr0r r:tuplerr< __classcell__r.r.r6r8r sR  V       & N)typingrrrrtorchrr#torchmetrics.functional.image.lpipsr4torchmetrics.functional.image.perceptual_path_lengthr r r r torchmetrics.metricr torchmetrics.utilities.importsr__doctest_skip__rr.r.r.r8s