Skip to content

Fréchet Inception Distance

Module for Fréchet Inception Distance (FID) metric implementation.

FrechetInceptionDistance

Bases: BaseMetric

Fréchet Inception Distance (FID) for evaluating generative models.

This metric measures the distance between the feature representations of real and generated images using the Inception-v3 model. Lower values indicate better quality and diversity.

Attributes:

Name Type Description
model

The generative model being evaluated.
dims

Dimensionality of Inception features to use.
inception

Pretrained Inception-v3 model used for feature extraction.
Source code in image_gen\metrics\fid.py 
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
class FrechetInceptionDistance(BaseMetric):
    """Fréchet Inception Distance (FID) for evaluating generative models.

    This metric measures the distance between the feature representations
    of real and generated images using the Inception-v3 model.
    Lower values indicate better quality and diversity.

    Attributes:
        model: The generative model being evaluated.
        dims: Dimensionality of Inception features to use.
        inception: Pretrained Inception-v3 model used for feature extraction.
    """

    def __init__(self, model: GenerativeModel, dims: int = 2048):
        """Initialize the FID metric with model and feature dimensions.

        Args:
            model: The generative model to be evaluated.
            dims: The feature dimension to use from the Inception model.
        """
        super().__init__(model)
        self.dims = dims
        self.inception = self._get_inception()

    def _get_inception(self):
        """Create and prepare the Inception-v3 model for feature extraction.

        Returns:
            The prepared Inception-v3 model with identity final layer.
        """
        inception = inception_v3(
            weights=Inception_V3_Weights.IMAGENET1K_V1, transform_input=False)
        inception.fc = nn.Identity()  # Remove final FC layer to get features
        inception.eval()
        inception.to(self.model.device)
        return inception

    def _get_activations(self, images: Tensor) -> np.ndarray:
        """Extract Inception features from input images.

        Args:
            images: Batch of images to process.

        Returns:
            NumPy array containing feature activations.
        """
        # Convert grayscale to RGB if needed
        if images.shape[1] == 1:
            images = images.repeat(1, 3, 1, 1)

        # Resize images to Inception input size
        if images.shape[2] != 299 or images.shape[3] != 299:
            images = F.interpolate(
                images,
                size=(299, 299),
                mode='bilinear',
                align_corners=True
            )

        # Scale from [-1, 1] to [0, 1] range if needed
        if images.min() < 0:
            images = (images + 1) / 2

        # Ensure values are in [0, 1]
        images = torch.clamp(images, 0, 1)

        # Extract features in smaller batches to avoid OOM errors
        batch_size = 32
        activations = []

        for i in range(0, images.shape[0], batch_size):
            batch = images[i:i+batch_size]
            with torch.no_grad():
                try:
                    batch_activations = self.inception(batch)
                    activations.append(batch_activations)
                except Exception as e:
                    print(f"Error processing batch: {e}")
                    # Return a fallback value if feature extraction fails
                    return np.random.randn(images.shape[0], self.dims)

        if not activations:
            return np.random.randn(images.shape[0], self.dims)

        activations = torch.cat(activations, 0)
        return activations.detach().cpu().numpy()

    def _calculate_fid(
        self,
        real_activations: np.ndarray,
        gen_activations: np.ndarray
    ) -> float:
        """Calculate FID score from feature activations.

        Args:
            real_activations: Feature activations from real images.
            gen_activations: Feature activations from generated images.

        Returns:
            The calculated FID score.
        """
        # Calculate mean and covariance
        mu1, sigma1 = real_activations.mean(
            axis=0), np.cov(real_activations, rowvar=False)
        mu2, sigma2 = gen_activations.mean(
            axis=0), np.cov(gen_activations, rowvar=False)

        # Handle numerical stability
        eps = 1e-6
        sigma1 += np.eye(sigma1.shape[0]) * eps
        sigma2 += np.eye(sigma2.shape[0]) * eps

        # Calculate FID
        ssdiff = np.sum((mu1 - mu2) ** 2)

        # Use scipy's sqrtm with error handling
        try:
            covmean_sqrt = linalg.sqrtm(sigma1.dot(sigma2), disp=False)[0]
            if np.iscomplexobj(covmean_sqrt):
                covmean_sqrt = covmean_sqrt.real
            fid = ssdiff + np.trace(sigma1 + sigma2 - 2 * covmean_sqrt)
        except Exception as e:
            print(f"Error calculating matrix square root: {e}")
            # Fallback to simpler calculation if sqrtm fails
            fid = ssdiff + np.trace(sigma1 + sigma2)

        return float(fid)

    def __call__(
        self,
        real: Union[Tensor, torch.utils.data.Dataset],
        generated: Union[Tensor, torch.utils.data.Dataset],
        *_,
        **__
    ) -> float:
        """Compute the FID score between real and generated images.

        Args:
            real: Tensor or Dataset-like containing real images (B, C, H, W).
            generated: Tensor or Dataset-like containing generated images 
                      (B, C, H, W).

        Returns:
            The computed FID score (lower is better).
        """
        def to_tensor(data):
            """Convert various inputs to tensors.

            Args:
                data: Input data (tensor or dataset).

            Returns:
                Tensor representation of the input data.
            """
            if isinstance(data, Tensor):
                return data
            dataloader = DataLoader(data, batch_size=64, shuffle=False)
            batch = next(iter(dataloader))
            return batch[0] if isinstance(batch, (list, tuple)) else batch

        real = to_tensor(real).to(self.model.device)
        generated = to_tensor(generated).to(self.model.device)

        # Process in batches to avoid memory issues
        real_activations = self._get_activations(real)
        gen_activations = self._get_activations(generated)

        # Ensure we have enough samples for covariance calculation
        if real_activations.shape[0] < 2 or gen_activations.shape[0] < 2:
            print("Warning: Need at least 2 samples for FID calculation")
            return float('nan')

        # If dimensions don't match (rare case), resize activations
        if real_activations.shape[0] != gen_activations.shape[0]:
            min_size = min(real_activations.shape[0], gen_activations.shape[0])
            real_activations = real_activations[:min_size]
            gen_activations = gen_activations[:min_size]

        return self._calculate_fid(real_activations, gen_activations)

    @property
    def name(self) -> str:
        """Get the name of the metric.

        Returns:
            The name of the metric.
        """
        return "Fréchet Inception Distance"

    @property
    def is_lower_better(self) -> bool:
        """Indicates whether a lower metric value is better.

        Returns:
            True if lower values indicate better performance.
        """
        return True

is_lower_better property

Indicates whether a lower metric value is better.

Returns:

Type Description
bool

True if lower values indicate better performance.

name property

Get the name of the metric.

Returns:

Type Description
str

The name of the metric.

__call__(real, generated, *_, **__)

Compute the FID score between real and generated images.

Parameters:

Name Type Description Default
real Union[Tensor, Dataset]

Tensor or Dataset-like containing real images (B, C, H, W).

 required
generated Union[Tensor, Dataset]

Tensor or Dataset-like containing generated images (B, C, H, W).

 required

Returns:

Type Description
float

The computed FID score (lower is better).
Source code in image_gen\metrics\fid.py 
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
def __call__(
    self,
    real: Union[Tensor, torch.utils.data.Dataset],
    generated: Union[Tensor, torch.utils.data.Dataset],
    *_,
    **__
) -> float:
    """Compute the FID score between real and generated images.

    Args:
        real: Tensor or Dataset-like containing real images (B, C, H, W).
        generated: Tensor or Dataset-like containing generated images 
                  (B, C, H, W).

    Returns:
        The computed FID score (lower is better).
    """
    def to_tensor(data):
        """Convert various inputs to tensors.

        Args:
            data: Input data (tensor or dataset).

        Returns:
            Tensor representation of the input data.
        """
        if isinstance(data, Tensor):
            return data
        dataloader = DataLoader(data, batch_size=64, shuffle=False)
        batch = next(iter(dataloader))
        return batch[0] if isinstance(batch, (list, tuple)) else batch

    real = to_tensor(real).to(self.model.device)
    generated = to_tensor(generated).to(self.model.device)

    # Process in batches to avoid memory issues
    real_activations = self._get_activations(real)
    gen_activations = self._get_activations(generated)

    # Ensure we have enough samples for covariance calculation
    if real_activations.shape[0] < 2 or gen_activations.shape[0] < 2:
        print("Warning: Need at least 2 samples for FID calculation")
        return float('nan')

    # If dimensions don't match (rare case), resize activations
    if real_activations.shape[0] != gen_activations.shape[0]:
        min_size = min(real_activations.shape[0], gen_activations.shape[0])
        real_activations = real_activations[:min_size]
        gen_activations = gen_activations[:min_size]

    return self._calculate_fid(real_activations, gen_activations)

__init__(model, dims=2048)

Initialize the FID metric with model and feature dimensions.

Parameters:

Name Type Description Default
model GenerativeModel

The generative model to be evaluated.

 required
dims int

The feature dimension to use from the Inception model.

 2048
Source code in image_gen\metrics\fid.py 
35
36
37
38
39
40
41
42
43
44
def __init__(self, model: GenerativeModel, dims: int = 2048):
    """Initialize the FID metric with model and feature dimensions.

    Args:
        model: The generative model to be evaluated.
        dims: The feature dimension to use from the Inception model.
    """
    super().__init__(model)
    self.dims = dims
    self.inception = self._get_inception()