pyiqa.archs.tres_arch
=====================

.. py:module:: pyiqa.archs.tres_arch

.. autoapi-nested-parse::

   TReS model.

   Reference:
       No-Reference Image Quality Assessment via Transformers, Relative Ranking, and Self-Consistency.
       S. Alireza Golestaneh, Saba Dadsetan, Kris M. Kitani
       WACV2022

   Official code: https://github.com/isalirezag/TReS







Module Contents
---------------

.. py:data:: default_model_urls

.. py:class:: Transformer(d_model=256, nhead=8, num_encoder_layers=6, num_decoder_layers=6, dim_feedforward=2048, dropout=0.1, activation='relu', normalize_before=False, return_intermediate_dec=False)

   Bases: :py:obj:`torch.nn.Module`


   Transformer encoder used by TReS to aggregate multiscale features.

   :param d_model: Feature dimension.
   :type d_model: int
   :param nhead: Number of attention heads.
   :type nhead: int
   :param num_encoder_layers: Number of encoder layers.
   :type num_encoder_layers: int
   :param num_decoder_layers: Unused legacy argument kept for compatibility.
   :type num_decoder_layers: int
   :param dim_feedforward: Hidden dimension in feed-forward blocks.
   :type dim_feedforward: int
   :param dropout: Dropout ratio.
   :type dropout: float
   :param activation: Activation function name.
   :type activation: str
   :param normalize_before: Whether to apply pre-normalization.
   :type normalize_before: bool
   :param return_intermediate_dec: Legacy compatibility argument.
   :type return_intermediate_dec: bool


   .. py:method:: forward(src, pos_embed)


.. py:class:: TransformerEncoder(encoder_layer, num_layers, norm=None)

   Bases: :py:obj:`torch.nn.Module`


   .. py:method:: forward(src, mask: Optional[torch.Tensor] = None, src_key_padding_mask: Optional[torch.Tensor] = None, pos: Optional[torch.Tensor] = None)


.. py:class:: TransformerEncoderLayer(d_model, nhead, dim_feedforward=2048, dropout=0.1, activation='relu', normalize_before=False)

   Bases: :py:obj:`torch.nn.Module`


   .. py:method:: with_pos_embed(tensor, pos: Optional[torch.Tensor])


   .. py:method:: forward_post(src, src_mask: Optional[torch.Tensor] = None, src_key_padding_mask: Optional[torch.Tensor] = None, pos: Optional[torch.Tensor] = None)


   .. py:method:: forward_pre(src, src_mask: Optional[torch.Tensor] = None, src_key_padding_mask: Optional[torch.Tensor] = None, pos: Optional[torch.Tensor] = None)


   .. py:method:: forward(src, src_mask: Optional[torch.Tensor] = None, src_key_padding_mask: Optional[torch.Tensor] = None, pos: Optional[torch.Tensor] = None)


.. py:class:: PositionEmbeddingSine(num_pos_feats=64, temperature=10000, normalize=False, scale=None)

   Bases: :py:obj:`torch.nn.Module`


   Sine-cosine positional encoding for 2D feature maps.

   This implementation is adapted from DETR-style positional encoding and
   generates a fixed embedding tensor with shape ``(N, C, H, W)``.


   .. py:method:: forward(tensor_val)


.. py:class:: L2pooling(filter_size=5, stride=1, channels=None, pad_off=0)

   Bases: :py:obj:`torch.nn.Module`


   L2 pooling with Hann-window smoothing.


   .. py:method:: forward(input)


.. py:class:: TReS(network='resnet50', train_dataset='koniq', nheadt=16, num_encoder_layerst=2, dim_feedforwardt=64, test_sample=50, default_mean=[0.485, 0.456, 0.406], default_std=[0.229, 0.224, 0.225], pretrained=True, pretrained_model_path=None)

   Bases: :py:obj:`torch.nn.Module`


   TReS no-reference IQA model.

   :param network: ResNet backbone name.
   :type network: str
   :param train_dataset: Dataset key used to choose default checkpoint.
   :type train_dataset: str
   :param nheadt: Number of transformer attention heads.
   :type nheadt: int
   :param num_encoder_layerst: Number of transformer encoder blocks.
   :type num_encoder_layerst: int
   :param dim_feedforwardt: Transformer feed-forward hidden size.
   :type dim_feedforwardt: int
   :param test_sample: Number of uniform crops during evaluation.
   :type test_sample: int
   :param default_mean: Input normalization mean in RGB order.
   :type default_mean: list[float]
   :param default_std: Input normalization std in RGB order.
   :type default_std: list[float]
   :param pretrained: Whether to load default pretrained checkpoint.
   :type pretrained: bool
   :param pretrained_model_path: Optional local checkpoint path.
   :type pretrained_model_path: str | None

   .. rubric:: Example

   >>> metric = TReS(train_dataset='koniq')
   >>> x = torch.rand(1, 3, 512, 512)
   >>> score = metric(x)


   .. py:method:: forward_backbone(model, x)


   .. py:method:: forward(x)

      Compute TReS quality score.

      :param x: Input tensor with shape ``(N, 3, H, W)``.
      :type x: torch.Tensor

      :returns: Predicted quality score with shape ``(N, 1)``.
      :rtype: torch.Tensor