NIQE (Natural Image Quality Evaluator)

The Natural Image Quality Evaluator (NIQE) scores the quality of a single image without a reference: there is no clean original to compare with, only the image itself. It rests on the observation that undistorted photographs share regular local statistics, and that blur, noise and compression change those statistics in measurable ways. NIQE summarizes the statistics of the image’s patches with a multivariate Gaussian and reports how far that Gaussian lies from one fitted, once and for all, to a corpus of pristine natural images. Lower is better. Mittal, Soundararajan and Bovik (2013) introduced it as a “completely blind” analyzer, in their terms opinion-unaware, because it is never trained on human quality scores, and distortion-unaware, because it never sees a distorted image during training. MATLAB calls the same method the Naturalness Image Quality Evaluator. NIQE belongs to the no-reference (“blind”) branch of image quality assessment, alongside full-reference metrics such as the mean squared error, PSNR and SSIM, which need the clean original.

Formula

NIQE works on a grayscale or luminance image $I$ with intensities in $[0, 255]$ and has four steps.

1. MSCN coefficients. Each pixel is normalized by a local mean and a local contrast (Mittal et al., 2013, eqs. 1–3):

$$\hat{I}(i, j) = \frac{I(i, j) - \mu(i, j)}{\sigma(i, j) + C}, \qquad \mu(i, j) = \sum_{k=-K}^{K} \sum_{l=-L}^{L} w_{k,l}\, I(i + k, j + l),$$ $$\sigma(i, j) = \sqrt{\sum_{k=-K}^{K} \sum_{l=-L}^{L} w_{k,l} \big[ I(i + k, j + l) - \mu(i, j) \big]^2 } ,$$

where $w$ is a circularly symmetric Gaussian window sampled out to three standard deviations with $K = L = 3$ (a $7 \times 7$ window) and normalized to sum to 1. The papers do not state the standard deviation; pyiqa’s implementation uses $7/6$, at which $K = 3$ corresponds to about 2.6 rather than 3 standard deviations (our arithmetic). The constant $C$ keeps the division stable where the local contrast is near zero, such as plain sky; both papers use $C = 1$. BRISQUE (Mittal, Moorthy & Bovik, 2012) named these values mean subtracted contrast normalized (MSCN) coefficients and noted that the operation models the contrast-gain masking of early human vision. Both papers cite Ruderman’s (1994) observation that, for natural images, such normalized values come close to a unit normal distribution.

2. Features per patch. The image is divided into $P \times P$ patches, and 18 parameters are fitted to the MSCN coefficients of each patch. Two come from a zero-mean generalized Gaussian distribution (GGD) fitted to the coefficients themselves (eq. 5):

$$f(x; \alpha, \beta) = \frac{\alpha}{2 \beta\, \Gamma(1/\alpha)} \exp\!\left( - \left( \frac{\lvert x \rvert}{\beta} \right)^{\alpha} \right),$$

where $\Gamma$ is the gamma function, $\alpha$ the shape and $\beta$ the scale. The shape $\alpha = 2$ gives a Gaussian and $\alpha = 1$ a Laplacian; smaller $\alpha$ means a sharper peak and heavier tails. The other 16 describe products of neighbouring coefficients, $\hat{I}(i, j)\hat{I}(i, j+1)$, $\hat{I}(i, j)\hat{I}(i+1, j)$, $\hat{I}(i, j)\hat{I}(i+1, j+1)$ and $\hat{I}(i, j)\hat{I}(i+1, j-1)$. Each orientation is fitted with an asymmetric generalized Gaussian (AGGD) with shape $\gamma$ and left and right scales $\beta_l, \beta_r$ (eq. 7):

$$f(x; \gamma, \beta_l, \beta_r) = \begin{cases} \dfrac{\gamma}{(\beta_l + \beta_r)\, \Gamma(1/\gamma)} \exp\!\left( - \left( \dfrac{-x}{\beta_l} \right)^{\gamma} \right), & x \le 0, \\[2ex] \dfrac{\gamma}{(\beta_l + \beta_r)\, \Gamma(1/\gamma)} \exp\!\left( - \left( \dfrac{x}{\beta_r} \right)^{\gamma} \right), & x \ge 0, \end{cases}$$

and contributes $\gamma$, $\beta_l$, $\beta_r$ and the distribution’s mean $\eta = (\beta_r - \beta_l)\, \Gamma(2/\gamma) / \Gamma(1/\gamma)$ (eq. 8). All parameters are estimated by moment matching: for the GGD, the ratio $(\mathbb{E}\lvert x \rvert)^2 / \mathbb{E}[x^2] = \Gamma(2/\alpha)^2 / \big(\Gamma(1/\alpha)\Gamma(3/\alpha)\big)$ fixes $\alpha$, after the method of Sharifi and Leon-Garcia, and the AGGD parameters come from the analogous method of Lasmar, Stitou and Berthoumieu; the papers cite both. The 18 features are computed again after low-pass filtering and downsampling the image by 2, giving 36 per patch.

3. The pristine model. Mittal et al. took 125 natural images, 480 × 320 to 1280 × 720 pixels, from copyright-free Flickr photos and the Berkeley segmentation database, with no content overlapping the test data. Only sharp patches enter the model: with patch sharpness $\delta(b) = \sum_{(i,j) \in b} \sigma(i, j)$ (eq. 4), a patch is kept if $\delta > p \cdot \max_b \delta(b)$, with $p = 0.75$. The reasoning is that most photographs contain some defocus blur and that viewers judge quality mainly from the sharp regions. A multivariate Gaussian (MVG) with mean $\nu_1$ and covariance $\Sigma_1$ is fitted to the 36-dimensional features of the kept patches by maximum likelihood (eq. 9).

4. The score. The test image’s patches are processed in the same way, with $P = 96$, but without sharpness selection, since a lack of sharpness in a test image is itself a distortion. A second MVG ($\nu_2$, $\Sigma_2$) is fitted to them, and the score is (eq. 10)

$$\mathrm{NIQE} = D(\nu_1, \nu_2, \Sigma_1, \Sigma_2) = \sqrt{ (\nu_1 - \nu_2)^{\top} \left( \frac{\Sigma_1 + \Sigma_2}{2} \right)^{-1} (\nu_1 - \nu_2) } .$$

This is a Mahalanobis distance between the two means under the averaged covariance $\Sigma = (\Sigma_1 + \Sigma_2)/2$. By our derivation, the Bhattacharyya distance between the two Gaussians is $D^2/8 + \tfrac{1}{2} \ln\!\big( \det \Sigma / \sqrt{\det \Sigma_1 \det \Sigma_2} \big)$; NIQE keeps only the first, mean term (as its square root, scaled by $\sqrt{8}$) and drops the term that compares the covariances directly, so the covariances only set the scale on which the mean shift is measured.

Intuition

Divisive normalization strips out what varies freely from image to image, the local brightness and contrast, and keeps what natural images have in common. In a clean photograph, the MSCN coefficients look roughly Gaussian, and the products of neighbours have a characteristic skew because neighbouring coefficients tend to share their sign. Distortions move these statistics in different directions. BRISQUE’s Figure 4 shows blur making the MSCN histogram more Laplacian-like and white noise reducing the weight of its tails; the products of neighbours change in their own ways (Figure 7). Each distortion leaves its own signature in the 36 features, and NIQE measures how far the image as a whole has moved from where natural images sit.

Nothing in this measures “quality” directly. NIQE measures unnaturalness, the distance from one statistical model of photographs. It predicts human judgments only insofar as the things that make an image look worse to people also make it statistically less natural.

Interpretation

NIQE is a nonnegative distance with no upper bound, and 0 would mean that the test image’s mean feature vector equals the pristine model’s. Lower is better. The scale has no absolute meaning, but values are comparable between images scored by the same implementation and pristine model. For orientation, MATLAB’s documentation example (R2026b, as of October 2026) scores a photograph at 2.55, a version with 2% salt-and-pepper noise at 10.88 and a Gaussian-blurred version at 5.27.

Mittal et al. (2013) evaluated NIQE on the LIVE IQA database: 29 reference images and 779 distorted versions with JPEG and JPEG2000 compression, white Gaussian noise, Gaussian blur and a simulated fast-fading channel, each with a difference mean opinion score (DMOS). To compare fairly with methods trained on LIVE, they split it by content into 80% training and 20% test 1000 times and report median correlations on the test parts, although NIQE itself trains on nothing from LIVE. Their Table I gives a median SROCC over all distortions of 0.9135 for NIQE, 0.9395 for BRISQUE, 0.9129 for SSIM, 0.8636 for PSNR and 0.9535 for MS-SSIM; the median linear correlation (Table II), computed after a logistic mapping to DMOS, is 0.9147 for NIQE. The text says NIQE performs better than PSNR and SSIM; against SSIM the overall margin is 0.0006 in SROCC, and per distortion NIQE is ahead on noise and blur but behind on both compressions and fast fading. A blind model that never saw human scores or distortions matched full-reference SSIM and came close to BRISQUE, which was trained on LIVE’s own distortions and scores; that was the paper’s result.

The paper reports that performance on LIVE changed little over patch sizes from 32 to 160 pixels and over $p$ from 0.6 to 0.9, and that a stable pristine model needs only a small set of images (its Figure 2).

When to Use It

NIQE fits situations where no reference exists and no human ratings are available for training:

• Perceptual super-resolution and restoration. When a method is designed to produce realistic detail rather than to match the ground truth pixel by pixel, full-reference fidelity metrics penalize it. The 2018 PIRM challenge on perceptual super-resolution (Blau et al., 2018) ranked submissions by a perceptual index, $\mathrm{PI} = \tfrac{1}{2}\big( (10 - \mathrm{Ma}) + \mathrm{NIQE} \big)$, where Ma is the learned no-reference super-resolution score of Ma et al. (2017); lower PI is better. PI and the RMSE were computed on the luma channel after removing a 4-pixel border, and the RMSE thresholds 11.5, 12.5 and 16 defined three regions of the perception–distortion plane, each with its own ranking. In the challenge’s study, 35 raters judged how real the outputs of the top 10 submissions and two baselines looked. Over the 10 submissions, the Spearman correlation between each submission’s mean opinion score and its mean metric score was 0.83 for PI, 0.76 for NIQE and 0.75 for LPIPS, while RMSE and SSIM were anti-correlated (Figure 9, the same in arXiv v3 and in the workshop paper on CVF Open Access). A per-image analysis of 480 outputs, after subtracting each image’s mean score, showed the same trend, with NIQE and PI the most correlated (Figure 10). Among the submissions rated best (mean opinion score above 2.3), the authors found only NIQE and PI still tracking the raters. They also note that PI agreed with the raters between regions but not always on the rankings within a region.
• Unconstrained collections. The case Mittal et al. had in mind: photo-upload sites, camera pipelines and other settings where the distortions are not known in advance.
• Monitoring and screening, where a large change in score flags an image or a processing step for a closer look.

When a clean reference exists and fidelity is the goal, as in classical image denoising benchmarks, full-reference metrics answer that question directly.

Failure Cases

Unnatural content scores as low quality. NIQE’s reference is a model of photographs. Mittal et al. note that the Gaussian behaviour of MSCN coefficients fails for images that do not come from a natural source, such as computer graphics. Text, documents, cartoons, medical and remote-sensing images and synthetic scenes can score badly without any distortion. The example below shows the same effect with a clean texture.

The pristine corpus is fixed. The model behind the reported numbers was fitted to 125 photographs. Implementations ship precomputed model parameters, and different parameter files give different numbers: pyiqa (IQA-PyTorch) offers both niqe and niqe_matlab, which load different parameter files (as of October 2026). A custom model can be fitted to any image set with MATLAB’s fitniqe, which then defines a different metric.

Weak agreement with humans on GAN artefacts. Gu et al. (2020) built PIPAL, a dataset of 1.13 million human judgements that includes outputs of restoration methods based on generative adversarial networks (GANs). In their Table 3, per-image SROCC on PIPAL was 0.1107 for NIQE on traditional distortions, 0.0320 on all super-resolution outputs and 0.0155 on the outputs of GAN-based super-resolution methods, against 0.5530 for the learned full-reference PieAPP on the GAN subset. Comparing the averages over 23 super-resolution algorithms (their Figure 3), they describe NIQE and PI as showing moderate performance, with LPIPS and PieAPP the most correlated. The PIPAL authors point out that their raters judged perceptual similarity to the ground truth, whereas PIRM’s raters judged whether an image looked real, which is closer to what NIQE measures. In our reading, that difference in the question asked, together with the different methods and images, accounts for the gap between the two studies more than the unit of analysis does, since PIRM also found NIQE well correlated on single images.

Small images give unstable fits. A 36-dimensional covariance must be estimated from the test image’s own patches. A 512 × 512 image holds 25 non-overlapping 96 × 96 patches, fewer than the 36 dimensions, so $\Sigma_2$ is singular (our arithmetic). The averaged matrix in eq. 10 usually stays invertible because $\Sigma_1$ is full rank, and pyiqa uses a pseudo-inverse there in any case, but the test image’s mean and covariance rest on very few samples, so the score of a small crop is noisy.

Intensity scale and colour. With $C = 1$, the MSCN step assumes intensities in $[0, 255]$; on images scaled to $[0, 1]$, $C$ would dominate $\sigma$ and change the features (our reasoning). Implementations work on one channel: pyiqa takes inputs in $[0, 1]$, converts colour images to luminance (by default the Y of YIQ, $0.299R + 0.587G + 0.114B$, the BT.601 luma weights), and rescales to $[0, 255]$ and rounds before computing the features, and PIRM cropped a 4-pixel border. Scores computed under different conventions are not comparable.

Mean shifts only. By the formula, two feature distributions with the same mean but different spread across patches have a distance of zero. Whether a distortion is caught depends on whether it moves the average features.

Variants

• BRISQUE (Mittal, Moorthy & Bovik, 2012) uses the same kind of 36 features, computed once per image and with variances in place of the GGD and AGGD scales, but learns a mapping to human scores with a support vector regressor with an RBF kernel, trained on distorted images and their DMOS. It is opinion-aware and distortion-aware: its Table II reports a median SROCC of 0.9395 on LIVE (1000 content-separated 80/20 splits), but it is tuned to the distortions it was trained on. MATLAB’s documentation for brisque likewise states that the image must have at least one of the distortions its default model was trained on (R2026a, as of October 2026).
• IL-NIQE (Zhang, Zhang & Bovik, 2015) enriches the natural-scene-statistics features with further cues, fits a pristine MVG to them, scores each patch with a Bhattacharyya-like distance and averages the patch scores into one number. Like NIQE it needs neither distorted images nor human scores.
• PIQE (Venkatanath et al., 2015) is another no-reference score; the algorithm in MATLAB’s documentation contains no pristine model. As that documentation describes it, PIQE computes MSCN coefficients, divides the image into 16 × 16 blocks, selects spatially active blocks, classifies them as distorted by blocking artefacts, by noise or undistorted using thresholds, and averages the scores of the distorted blocks into a score in $[0, 100]$, lower being better.
• The perceptual index of PIRM, above, combines NIQE with Ma et al.’s learned score.

MATLAB’s Image Processing Toolbox provides niqe, fitniqe, brisque, fitbrisque and piqe, and pyiqa lists niqe, ilniqe, brisque and piqe, all marked lower-is-better in its model card (as of October 2026). Pyiqa’s NIQE downloads its precomputed pristine parameters on first use.

Example

The example builds the mechanics in NumPy and SciPy on synthetic grayscale images in $[0, 255]$. The clean images are 512 × 512 “dead leaves” scenes: 16,000 overlapping disks with random grey levels and radii with density proportional to $r^{-3}$, so that later disks occlude earlier ones. The first part computes MSCN coefficients ($7 \times 7$ Gaussian window with standard deviation 7/6, as in pyiqa’s implementation; $C = 1$) for one scene and for blurred and noisy versions, and prints the fitted GGD shape $\alpha$, the scale $\beta$ and the correlation between horizontal neighbours. The second part is a simplified NIQE-style score: the pristine model is fitted to sharp patches ($p = 0.75$) of 20 other clean synthetic scenes, patches are 64 × 64, the second scale is a 2 × 2 average, and the score is eq. 10. The real NIQE uses its own pristine model of 125 photographs, 96 × 96 patches and a different resampling filter, so these numbers are not NIQE values.

import numpy as np
from scipy.ndimage import correlate, gaussian_filter
from scipy.special import gammaln

def dead_leaves(seed, n=512, k=16000):
    """Synthetic 'natural-like' scene: occluding disks of random grey level,
    radii with density proportional to r^-3, intensities in [0, 255]."""
    rng = np.random.default_rng(seed)
    img = np.full((n, n), 128.0)
    yy, xx = np.mgrid[0:n, 0:n]
    r = (2.0**-2 - rng.random(k) * (2.0**-2 - 64.0**-2)) ** -0.5   # 2 <= r <= 64
    cy, cx = rng.uniform(-20, n + 20, (2, k))
    grey = rng.uniform(20, 235, k)
    for i in range(k):                       # later disks occlude earlier ones
        y0, y1 = max(int(cy[i] - r[i]), 0), min(int(cy[i] + r[i]) + 1, n)
        x0, x1 = max(int(cx[i] - r[i]), 0), min(int(cx[i] + r[i]) + 1, n)
        if y0 < y1 and x0 < x1:
            m = (yy[y0:y1, x0:x1] - cy[i])**2 + (xx[y0:y1, x0:x1] - cx[i])**2 <= r[i]**2
            img[y0:y1, x0:x1][m] = grey[i]
    return gaussian_filter(img, 0.7)         # soften the edges slightly

ax = np.arange(-3, 4)                         # 7x7 Gaussian window, sigma = 7/6
g = np.exp(-ax**2 / (2 * (7 / 6)**2))
W = np.outer(g, g) / np.outer(g, g).sum()

def mscn(img, C=1.0):
    mu = correlate(img, W, mode="nearest")
    sigma = np.sqrt(np.abs(correlate(img**2, W, mode="nearest") - mu**2))
    return (img - mu) / (sigma + C), sigma

ALPHAS = np.arange(0.2, 10.0005, 0.001)       # shape grid searched by moment matching
RATIO = np.exp(2 * gammaln(2 / ALPHAS) - gammaln(1 / ALPHAS) - gammaln(3 / ALPHAS))

def shape_from_ratio(r):  # solve Gamma(2/a)^2 / (Gamma(1/a) Gamma(3/a)) = r on the grid
    return ALPHAS[np.argmin(np.abs(RATIO - r))]

def fit_ggd(x):
    """Moment matching: (E|x|)^2 / E[x^2] fixes alpha; beta follows from E[x^2]."""
    a = shape_from_ratio(np.mean(np.abs(x))**2 / np.mean(x**2))
    return a, np.sqrt(np.mean(x**2) * np.exp(gammaln(1 / a) - gammaln(3 / a)))

def fit_aggd(x):
    """Asymmetric GGD by moment matching; returns shape, mean (eq. 8), beta_l, beta_r."""
    sl, sr = np.sqrt(np.mean(x[x < 0]**2)), np.sqrt(np.mean(x[x > 0]**2))
    gh = sl / sr
    rh = np.mean(np.abs(x))**2 / np.mean(x**2) * (gh**3 + 1) * (gh + 1) / (gh**2 + 1)**2
    a = shape_from_ratio(rh)
    k = np.sqrt(np.exp(gammaln(1 / a) - gammaln(3 / a)))
    bl, br = sl * k, sr * k
    return a, (br - bl) * np.exp(gammaln(2 / a) - gammaln(1 / a)), bl, br

def patch_features(m):
    """18 features of one MSCN patch: GGD (alpha, beta) + 4 x AGGD on neighbour products."""
    f = list(fit_ggd(m.ravel()))
    for p in (m[:, :-1] * m[:, 1:], m[:-1, :] * m[1:, :],         # H, V
              m[:-1, :-1] * m[1:, 1:], m[:-1, 1:] * m[1:, :-1]):  # D1, D2
        f += fit_aggd(p.ravel())
    return f

def features(img, P=64, select=None):
    """36 features per P x P patch (two scales). select = p keeps sharp patches only."""
    feats, sharp = [], None
    for scale in (1, 2):
        m, sigma = mscn(img)
        n = img.shape[0] // (P // scale)
        blocks = [(i, j) for i in range(n) for j in range(n)]
        s = P // scale
        if scale == 1:
            sharp = np.array([sigma[i*s:(i+1)*s, j*s:(j+1)*s].sum() for i, j in blocks])
        feats.append([patch_features(m[i*s:(i+1)*s, j*s:(j+1)*s]) for i, j in blocks])
        img = img.reshape(img.shape[0] // 2, 2, -1, 2).mean(axis=(1, 3))  # low-pass, downsample
    F = np.hstack([np.array(f) for f in feats])
    return F if select is None else F[sharp > select * sharp.max()]

def distance(F_pris, F_test):
    """NIQE's eq. (10) between MVG fits of two feature sets."""
    nu1, nu2 = F_pris.mean(0), F_test.mean(0)
    S = (np.cov(F_pris, rowvar=False) + np.cov(F_test, rowvar=False)) / 2
    d = nu1 - nu2
    return np.sqrt(d @ np.linalg.pinv(S) @ d)

def pink_texture(seed, n=512):
    """A clean image of a different kind: Gaussian noise with a 1/f amplitude spectrum."""
    f = np.fft.fftfreq(n)
    F = np.hypot(*np.meshgrid(f, f))
    F[0, 0] = np.inf
    t = np.real(np.fft.ifft2(np.fft.fft2(np.random.default_rng(seed).standard_normal((n, n))) / F))
    return 128 + 40 * t / t.std()

# 1) How distortion changes the MSCN statistics of one image.
clean = dead_leaves(0)
rng = np.random.default_rng(1)
versions = {"clean": clean}
for s in (1, 2, 3):
    versions[f"blur sigma={s}"] = gaussian_filter(clean, s)
for s in (5, 10, 20):
    versions[f"noise sigma={s}"] = clean + s * rng.standard_normal(clean.shape)
print(f"{'image':16s} {'alpha':>6s} {'beta':>6s} {'corr(H)':>8s}")
for name, img in versions.items():
    m, _ = mscn(img)
    a, b = fit_ggd(m.ravel())
    corr = np.corrcoef(m[:, :-1].ravel(), m[:, 1:].ravel())[0, 1]
    print(f"{name:16s} {a:6.2f} {b:6.3f} {corr:8.2f}")

# 2) A simplified NIQE: pristine model from 20 clean synthetic scenes.
F_pris = np.vstack([features(dead_leaves(100 + k), select=0.75) for k in range(20)])
print(f"\npristine model: {F_pris.shape[0]} sharp patches x {F_pris.shape[1]} features")
scores = {name: [] for name in list(versions) + ["clean 1/f texture"]}
for seed in range(5):                              # five unseen test scenes
    clean = dead_leaves(seed)
    rng = np.random.default_rng(1000 + seed)
    for name in versions:
        if name == "clean":
            img = clean
        elif name.startswith("blur"):
            img = gaussian_filter(clean, float(name.split("=")[1]))
        else:
            img = clean + float(name.split("=")[1]) * rng.standard_normal(clean.shape)
        scores[name].append(distance(F_pris, features(img)))
    scores["clean 1/f texture"].append(distance(F_pris, features(pink_texture(seed))))
print(f"{'image':17s} {'mean':>6s} {'min':>6s} {'max':>6s}   (simplified NIQE, 5 scenes)")
for name, s in scores.items():
    print(f"{name:17s} {np.mean(s):6.2f} {np.min(s):6.2f} {np.max(s):6.2f}")

Output (NumPy 2.3.5, SciPy 1.16.3):

image             alpha   beta  corr(H)
clean              2.01  0.539     0.70
blur sigma=1       2.02  0.472     0.85
blur sigma=2       1.78  0.356     0.91
blur sigma=3       1.60  0.260     0.94
noise sigma=5      3.15  0.943     0.20
noise sigma=10     2.56  1.021     0.08
noise sigma=20     2.51  1.151    -0.02

pristine model: 565 sharp patches x 36 features
image               mean    min    max   (simplified NIQE, 5 scenes)
clean               1.47   1.19   1.84
blur sigma=1       18.08  16.74  19.39
blur sigma=2       29.70  27.41  32.74
blur sigma=3       39.95  38.72  41.00
noise sigma=5      14.59  13.09  16.47
noise sigma=10     20.65  19.58  21.86
noise sigma=20     27.06  26.22  28.10
clean 1/f texture  37.83  36.25  40.73

The clean scene’s MSCN coefficients have a GGD shape of almost exactly 2, the Gaussian that Ruderman’s observation predicts. The two distortions push the statistics in opposite directions. Blur removes fine variation, so the coefficients shrink (smaller $\beta$), neighbours become more alike, and with stronger blur the shape falls towards the Laplacian, as in BRISQUE’s histograms. Noise adds independent variation, so the scale grows, the neighbour correlation collapses to zero, and the distribution becomes flatter-topped than a Gaussian ($\alpha > 2$). The shape is not monotone in the noise level, peaking at the weakest noise, but the scale and the correlation keep moving, and the score combines all 36 features.

The simplified score orders every distortion by severity, and the ranges over the five test scenes do not overlap between levels. The clean scenes score above 0 because a mean estimated from 64 patches differs from the pristine mean by chance. The last line is the failure case: a clean 1/f texture, with nothing degraded, scores about as badly as the strongest blur, because its statistics are unlike those of the scenes the model was fitted to. With a pristine model of photographs, the same can happen to image classes outside that corpus.

Related Metrics

• Full-reference metrics compare with a clean original: the mean squared error and PSNR measure pixel fidelity, SSIM local structure, and LPIPS distances between deep features. In PIRM’s analysis, RMSE and SSIM ranked perceptual super-resolution methods opposite to the raters, while LPIPS agreed with them about as well as NIQE did overall.
• Fréchet Inception Distance also compares two fitted Gaussians, but between sets of real images and images from a generative model, in Inception-v3 features, and with a term that compares the covariances.