aac_metrics.classes package

class BERTScoreMRefs(

return_all_scores: bool = True,

*,

model: str | Module = 'roberta-large',

device: str | device | None = 'cuda_if_available',

batch_size: int | None = 32,

num_threads: int = 0,

max_length: int = 64,

reset_state: bool = True,

idf: bool = False,

reduction: Literal['mean', 'max', 'min'] | Callable[[...], Tensor] = 'max',

filter_nan: bool = True,

verbose: int = 0,

)

Bases: AACMetric[tuple[BERTScoreMRefsScores, BERTScoreMRefsScores] | Tensor]

BERTScore metric which supports multiple references.

The implementation is based on the bert_score implementation of torchmetrics.

• Paper: https://arxiv.org/pdf/1904.09675.pdf

For more information, see bert_score_mrefs().

compute() → tuple[BERTScoreMRefsScores, BERTScoreMRefsScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 1.0

min_value: ClassVar[float] = 0.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class BLEU(return_all_scores: bool = True, *, n: int = 4, option: ~typing.Literal['shortest', 'average', 'closest'] = 'closest', verbose: int = 0, tokenizer: ~typing.Callable[[str], list[str]] = <method 'split' of 'str' objects>)

Bases: AACMetric[tuple[dict[str, Tensor], dict[str, Tensor]] | Tensor]

BiLingual Evaluation Understudy metric class.

• Paper: https://www.aclweb.org/anthology/P02-1040.pdf

For more information, see bleu().

compute() → tuple[dict[str, Tensor], dict[str, Tensor]] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 1.0

min_value: ClassVar[float] = 0.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class BLEU1(return_all_scores: bool = True, option: ~typing.Literal['shortest', 'average', 'closest'] = 'closest', verbose: int = 0, tokenizer: ~typing.Callable[[str], list[str]] = <method 'split' of 'str' objects>)

Bases: BLEU

class BLEU2(return_all_scores: bool = True, option: ~typing.Literal['shortest', 'average', 'closest'] = 'closest', verbose: int = 0, tokenizer: ~typing.Callable[[str], list[str]] = <method 'split' of 'str' objects>)

Bases: BLEU

class BLEU3(return_all_scores: bool = True, option: ~typing.Literal['shortest', 'average', 'closest'] = 'closest', verbose: int = 0, tokenizer: ~typing.Callable[[str], list[str]] = <method 'split' of 'str' objects>)

Bases: BLEU

class BLEU4(return_all_scores: bool = True, option: ~typing.Literal['shortest', 'average', 'closest'] = 'closest', verbose: int = 0, tokenizer: ~typing.Callable[[str], list[str]] = <method 'split' of 'str' objects>)

Bases: BLEU

class CIDErD(return_all_scores: bool = True, *, n: int = 4, sigma: float = 6.0, tokenizer: ~typing.Callable[[str], list[str]] = <method 'split' of 'str' objects>, return_tfidf: bool = False, scale: float = 10.0)

Bases: AACMetric[tuple[CIDErDScores, CIDErDScores] | Tensor]

Consensus-based Image Description Evaluation metric class.

• Paper: https://arxiv.org/pdf/1411.5726.pdf

For more information, see cider_d().

compute() → tuple[CIDErDScores, CIDErDScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 10.0

min_value: ClassVar[float] = 0.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class CLAPSim(

return_all_scores: bool = True,

*,

clap_method: Literal['audio', 'text'] = 'text',

clap_model: str | CLAPWrapper = 'MS-CLAP-2023',

device: str | device | None = 'cuda_if_available',

batch_size: int | None = 32,

reset_state: bool = True,

seed: int | None = 42,

verbose: int = 0,

)

Bases: AACMetric[tuple[CLAPScores, CLAPScores] | Tensor]

Cosine-similarity of the Contrastive Language-Audio Pretraining (CLAP) embeddings.

The implementation is based on the msclap pypi package. Note: Instances of this class are not pickable.

• Paper: https://arxiv.org/pdf/2411.00321

• msclap package: https://pypi.org/project/msclap/

For more information, see clap_sim().

compute() → tuple[CLAPScores, CLAPScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 1.0

min_value: ClassVar[float] = -1.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references_or_audio_paths: list[list[str]] | list[str],

) → None

class DCASE2023Evaluate(

preprocess: bool = True,

cache_path: str | Path | None = None,

java_path: str | Path | None = None,

tmp_path: str | Path | None = None,

device: str | device | None = 'cuda_if_available',

verbose: int = 0,

)

Bases: Evaluate

Evaluate candidates with multiple references with DCASE2023 Audio Captioning metrics.

For more information, see dcase2023_evaluate().

class DCASE2024Evaluate(

preprocess: bool = True,

cache_path: str | Path | None = None,

java_path: str | Path | None = None,

tmp_path: str | Path | None = None,

device: str | device | None = 'cuda_if_available',

verbose: int = 0,

)

Bases: Evaluate

Evaluate candidates with multiple references with DCASE2024 Audio Captioning metrics.

For more information, see dcase2024_evaluate().

class Evaluate(

preprocess: bool | Callable[[list[str]], list[str]] = True,

metrics: str | Iterable[str] | Iterable[AACMetric] = 'default',

cache_path: str | Path | None = None,

java_path: str | Path | None = None,

tmp_path: str | Path | None = None,

device: str | device | None = 'cuda_if_available',

verbose: int = 0,

)

Bases: list[AACMetric], AACMetric[tuple[dict[str, Tensor], dict[str, Tensor]]]

Evaluate candidates with multiple references with custom metrics.

For more information, see evaluate().

compute() → tuple[dict[str, Tensor], dict[str, Tensor]]

full_state_update: ClassVar[bool | None] = False

higher_is_better: ClassVar[bool | None] = None

is_differentiable: ClassVar[bool | None] = False

reset() → None

tolist() → list[AACMetric]

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class FENSE(

return_all_scores: bool = True,

*,

sbert_model: str | SentenceTransformer = 'paraphrase-TinyBERT-L6-v2',

echecker: str | BERTFlatClassifier = 'echecker_clotho_audiocaps_base',

echecker_tokenizer: AutoTokenizer | None = None,

error_threshold: float = 0.9,

device: str | device | None = 'cuda_if_available',

batch_size: int | None = 32,

reset_state: bool = True,

return_probs: bool = False,

penalty: float = 0.9,

verbose: int = 0,

)

Bases: AACMetric[tuple[FENSEScores, FENSEScores] | Tensor]

Fluency ENhanced Sentence-bert Evaluation (FENSE)

• Paper: https://arxiv.org/abs/2110.04684

• Original implementation: https://github.com/blmoistawinde/fense

For more information, see fense().

compute() → tuple[FENSEScores, FENSEScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 1.0

min_value: ClassVar[float] = -1.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class FER(

return_all_scores: bool = True,

*,

echecker: str | BERTFlatClassifier = 'echecker_clotho_audiocaps_base',

error_threshold: float = 0.9,

device: str | device | None = 'cuda_if_available',

batch_size: int | None = 32,

reset_state: bool = True,

return_probs: bool = False,

verbose: int = 0,

)

Bases: AACMetric[tuple[FERScores, FERScores] | Tensor]

Return Fluency Error Rate (FER) detected by a pre-trained BERT model.

• Paper: https://arxiv.org/abs/2110.04684

• Original implementation: https://github.com/blmoistawinde/fense

For more information, see fer().

compute() → tuple[FERScores, FERScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = False

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 1.0

min_value: ClassVar[float] = -1.0

reset() → None

training: bool

update(

candidates: list[str],

*args,

**kwargs,

) → None

class MACE(

return_all_scores: bool = True,

*,

mace_method: Literal['text', 'audio', 'combined'] = 'text',

penalty: float = 0.3,

clap_model: str | CLAPWrapper = 'MS-CLAP-2023',

seed: int | None = 42,

echecker: str | BERTFlatClassifier = 'echecker_clotho_audiocaps_base',

echecker_tokenizer: AutoTokenizer | None = None,

error_threshold: float = 0.97,

device: str | device | None = 'cuda_if_available',

batch_size: int | None = 32,

reset_state: bool = True,

return_probs: bool = False,

verbose: int = 0,

)

Bases: AACMetric[tuple[MACEScores, MACEScores] | Tensor]

Multimodal Audio-Caption Evaluation class (MACE).

MACE is a metric designed for evaluating automated audio captioning (AAC) systems. Unlike metrics that compare machine-generated captions solely to human references, MACE uses both audio and text to improve evaluation. By integrating both audio and text, it produces assessments that align better with human judgments.

The implementation is based on the mace original implementation (original author have accepted to include their code in aac-metrics under the MIT license). Note: Instances of this class are not pickable.

• Paper: https://arxiv.org/pdf/2411.00321

• Original author: Satvik Dixit

• Original implementation: https://github.com/satvik-dixit/mace/tree/main

For more information, see mace().

compute() → tuple[MACEScores, MACEScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 1.0

min_value: ClassVar[float] = -1.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]] | None = None,

audio_paths: list[str] | None = None,

) → None

class METEOR(

return_all_scores: bool = True,

*,

cache_path: str | Path | None = None,

java_path: str | Path | None = None,

java_max_memory: str = '2G',

language: Literal['en', 'cz', 'de', 'es', 'fr'] = 'en',

use_shell: bool | None = None,

params: Iterable[float] | None = None,

weights: Iterable[float] | None = None,

verbose: int = 0,

)

Bases: AACMetric[tuple[METEORScores, METEORScores] | Tensor]

Metric for Evaluation of Translation with Explicit ORdering metric class.

• Paper: https://dl.acm.org/doi/pdf/10.5555/1626355.1626389

• Documentation: https://www.cs.cmu.edu/~alavie/METEOR/README.html

For more information, see meteor().

compute() → tuple[METEORScores, METEORScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 1.0

min_value: ClassVar[float] = 0.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class ROUGEL(return_all_scores: bool = True, *, beta: float = 1.2, tokenizer: ~typing.Callable[[str], list[str]] = <method 'split' of 'str' objects>)

Bases: AACMetric[tuple[ROUGELScores, ROUGELScores] | Tensor]

Recall-Oriented Understudy for Gisting Evaluation class.

• Paper: https://aclanthology.org/W04-1013.pdf

For more information, see rouge_l().

compute() → tuple[ROUGELScores, ROUGELScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 1.0

min_value: ClassVar[float] = 0.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class SBERTSim(

return_all_scores: bool = True,

*,

sbert_model: str | SentenceTransformer = 'paraphrase-TinyBERT-L6-v2',

device: str | device | None = 'cuda_if_available',

batch_size: int | None = 32,

reset_state: bool = True,

verbose: int = 0,

)

Bases: AACMetric[tuple[SBERTSimScores, SBERTSimScores] | Tensor]

Cosine-similarity of the Sentence-BERT embeddings.

• Paper: https://arxiv.org/abs/1908.10084

• Original implementation: https://github.com/blmoistawinde/fense

For more information, see sbert().

compute() → tuple[SBERTSimScores, SBERTSimScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 1.0

min_value: ClassVar[float] = -1.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class SPICE(

return_all_scores: bool = True,

*,

cache_path: str | Path | None = None,

java_path: str | Path | None = None,

tmp_path: str | Path | None = None,

n_threads: int | None = None,

java_max_memory: str = '8G',

timeout: None | int | Iterable[int] = None,

separate_cache_dir: bool = True,

use_shell: bool | None = None,

verbose: int = 0,

)

Bases: AACMetric[tuple[SPICEScores, SPICEScores] | Tensor]

Semantic Propositional Image Caption Evaluation class.

• Paper: https://arxiv.org/pdf/1607.08822.pdf

For more information, see spice().

compute() → tuple[SPICEScores, SPICEScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 1.0

min_value: ClassVar[float] = 0.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class SPIDEr(

return_all_scores: bool = True,

*,

n: int = 4,

sigma: float = 6.0,

cache_path: str | Path | None = None,

java_path: str | Path | None = None,

tmp_path: str | Path | None = None,

n_threads: int | None = None,

java_max_memory: str = '8G',

timeout: None | int | Iterable[int] = None,

verbose: int = 0,

)

Bases: AACMetric[tuple[SPIDErScores, SPIDErScores] | Tensor]

SPIDEr class.

• Paper: https://arxiv.org/pdf/1612.00370.pdf

For more information, see spider().

compute() → tuple[SPIDErScores, SPIDErScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 5.5

min_value: ClassVar[float] = 0.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class SPIDErFL(

return_all_scores: bool = True,

*,

n: int = 4,

sigma: float = 6.0,

cache_path: str | Path | None = None,

java_path: str | Path | None = None,

tmp_path: str | Path | None = None,

n_threads: int | None = None,

java_max_memory: str = '8G',

timeout: None | int | Iterable[int] = None,

echecker: str | BERTFlatClassifier = 'echecker_clotho_audiocaps_base',

echecker_tokenizer: AutoTokenizer | None = None,

error_threshold: float = 0.9,

device: str | device | None = 'cuda_if_available',

batch_size: int | None = 32,

reset_state: bool = True,

return_probs: bool = True,

penalty: float = 0.9,

verbose: int = 0,

)

Bases: AACMetric[tuple[SPIDErFLScores, SPIDErFLScores] | Tensor]

SPIDErFL class.

For more information, see spider_fl().

compute() → tuple[SPIDErFLScores, SPIDErFLScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 5.5

min_value: ClassVar[float] = 0.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]],

) → None

class SPIDErMax(

return_all_scores: bool = True,

*,

return_all_cands_scores: bool = False,

n: int = 4,

sigma: float = 6.0,

cache_path: str | Path | None = None,

java_path: str | Path | None = None,

tmp_path: str | Path | None = None,

n_threads: int | None = None,

java_max_memory: str = '8G',

timeout: None | int | Iterable[int] = None,

verbose: int = 0,

)

Bases: AACMetric[tuple[SPIDErMaxScores, SPIDErMaxScores] | Tensor]

SPIDEr-max class.

• Paper: https://hal.archives-ouvertes.fr/hal-03810396/file/Labbe_DCASE2022.pdf

For more information, see spider().

compute() → tuple[SPIDErMaxScores, SPIDErMaxScores] | Tensor

extra_repr() → str

Return the extra representation of the module.

To print customized extra information, you should re-implement this method in your own modules. Both single-line and multi-line strings are acceptable.

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = True

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = 5.5

min_value: ClassVar[float] = 0.0

reset() → None

training: bool

update(

mult_candidates: list[list[str]],

mult_references: list[list[str]],

) → None

class Vocab(return_all_scores: bool = True, *, seed: None | int | ~torch._C.Generator = 1234, tokenizer: ~typing.Callable[[str], list[str]] = <method 'split' of 'str' objects>, dtype: ~torch.dtype = torch.float64, pop_strategy: ~typing.Literal['max', 'min'] | int = 'max', verbose: int = 0)

Bases: AACMetric[tuple[VocabScores, VocabScores] | Tensor]

VocabStats class.

For more information, see vocab().

compute() → tuple[VocabScores, VocabScores] | Tensor

full_state_update: ClassVar[bool | None] = False

get_output_names() → tuple[str, ...]

higher_is_better: ClassVar[bool | None] = None

is_differentiable: ClassVar[bool | None] = False

max_value: ClassVar[float] = inf

min_value: ClassVar[float] = 0.0

reset() → None

training: bool

update(

candidates: list[str],

mult_references: list[list[str]] | None = None,

) → None

Submodules

• aac_metrics.classes.base module
  • AACMetric
    • AACMetric.compute()
    • AACMetric.forward()
    • AACMetric.full_state_update
    • AACMetric.higher_is_better
    • AACMetric.is_differentiable
    • AACMetric.max_value
    • AACMetric.min_value
    • AACMetric.reset()
    • AACMetric.training
    • AACMetric.update()
• aac_metrics.classes.bert_score_mrefs module
  • BERTScoreMRefs
    • BERTScoreMRefs.compute()
    • BERTScoreMRefs.extra_repr()
    • BERTScoreMRefs.full_state_update
    • BERTScoreMRefs.get_output_names()
    • BERTScoreMRefs.higher_is_better
    • BERTScoreMRefs.is_differentiable
    • BERTScoreMRefs.max_value
    • BERTScoreMRefs.min_value
    • BERTScoreMRefs.reset()
    • BERTScoreMRefs.training
    • BERTScoreMRefs.update()
• aac_metrics.classes.bleu module
  • BLEU
    • BLEU.compute()
    • BLEU.extra_repr()
    • BLEU.full_state_update
    • BLEU.get_output_names()
    • BLEU.higher_is_better
    • BLEU.is_differentiable
    • BLEU.max_value
    • BLEU.min_value
    • BLEU.reset()
    • BLEU.training
    • BLEU.update()
  • BLEU1
  • BLEU2
  • BLEU3
  • BLEU4
• aac_metrics.classes.cider_d module
  • CIDErD
    • CIDErD.compute()
    • CIDErD.extra_repr()
    • CIDErD.full_state_update
    • CIDErD.get_output_names()
    • CIDErD.higher_is_better
    • CIDErD.is_differentiable
    • CIDErD.max_value
    • CIDErD.min_value
    • CIDErD.reset()
    • CIDErD.training
    • CIDErD.update()
• aac_metrics.classes.clap_sim module
  • CLAPSim
    • CLAPSim.compute()
    • CLAPSim.extra_repr()
    • CLAPSim.full_state_update
    • CLAPSim.get_output_names()
    • CLAPSim.higher_is_better
    • CLAPSim.is_differentiable
    • CLAPSim.max_value
    • CLAPSim.min_value
    • CLAPSim.reset()
    • CLAPSim.training
    • CLAPSim.update()
• aac_metrics.classes.evaluate module
  • DCASE2023Evaluate
  • DCASE2024Evaluate
  • Evaluate
    • Evaluate.compute()
    • Evaluate.full_state_update
    • Evaluate.higher_is_better
    • Evaluate.is_differentiable
    • Evaluate.reset()
    • Evaluate.tolist()
    • Evaluate.training
    • Evaluate.update()
• aac_metrics.classes.fense module
  • FENSE
    • FENSE.compute()
    • FENSE.extra_repr()
    • FENSE.full_state_update
    • FENSE.get_output_names()
    • FENSE.higher_is_better
    • FENSE.is_differentiable
    • FENSE.max_value
    • FENSE.min_value
    • FENSE.reset()
    • FENSE.training
    • FENSE.update()
• aac_metrics.classes.fer module
  • FER
    • FER.compute()
    • FER.extra_repr()
    • FER.full_state_update
    • FER.get_output_names()
    • FER.higher_is_better
    • FER.is_differentiable
    • FER.max_value
    • FER.min_value
    • FER.reset()
    • FER.training
    • FER.update()
• aac_metrics.classes.mace module
  • MACE
    • MACE.compute()
    • MACE.extra_repr()
    • MACE.full_state_update
    • MACE.get_output_names()
    • MACE.higher_is_better
    • MACE.is_differentiable
    • MACE.max_value
    • MACE.min_value
    • MACE.reset()
    • MACE.training
    • MACE.update()
• aac_metrics.classes.meteor module
  • METEOR
    • METEOR.compute()
    • METEOR.extra_repr()
    • METEOR.full_state_update
    • METEOR.get_output_names()
    • METEOR.higher_is_better
    • METEOR.is_differentiable
    • METEOR.max_value
    • METEOR.min_value
    • METEOR.reset()
    • METEOR.training
    • METEOR.update()
• aac_metrics.classes.rouge_l module
  • ROUGEL
    • ROUGEL.compute()
    • ROUGEL.extra_repr()
    • ROUGEL.full_state_update
    • ROUGEL.get_output_names()
    • ROUGEL.higher_is_better
    • ROUGEL.is_differentiable
    • ROUGEL.max_value
    • ROUGEL.min_value
    • ROUGEL.reset()
    • ROUGEL.training
    • ROUGEL.update()
• aac_metrics.classes.sbert_sim module
  • SBERTSim
    • SBERTSim.compute()
    • SBERTSim.extra_repr()
    • SBERTSim.full_state_update
    • SBERTSim.get_output_names()
    • SBERTSim.higher_is_better
    • SBERTSim.is_differentiable
    • SBERTSim.max_value
    • SBERTSim.min_value
    • SBERTSim.reset()
    • SBERTSim.training
    • SBERTSim.update()
• aac_metrics.classes.spice module
  • SPICE
    • SPICE.compute()
    • SPICE.extra_repr()
    • SPICE.full_state_update
    • SPICE.get_output_names()
    • SPICE.higher_is_better
    • SPICE.is_differentiable
    • SPICE.max_value
    • SPICE.min_value
    • SPICE.reset()
    • SPICE.training
    • SPICE.update()
• aac_metrics.classes.spider module
  • SPIDEr
    • SPIDEr.compute()
    • SPIDEr.extra_repr()
    • SPIDEr.full_state_update
    • SPIDEr.get_output_names()
    • SPIDEr.higher_is_better
    • SPIDEr.is_differentiable
    • SPIDEr.max_value
    • SPIDEr.min_value
    • SPIDEr.reset()
    • SPIDEr.training
    • SPIDEr.update()
• aac_metrics.classes.spider_fl module
  • SPIDErFL
    • SPIDErFL.compute()
    • SPIDErFL.extra_repr()
    • SPIDErFL.full_state_update
    • SPIDErFL.get_output_names()
    • SPIDErFL.higher_is_better
    • SPIDErFL.is_differentiable
    • SPIDErFL.max_value
    • SPIDErFL.min_value
    • SPIDErFL.reset()
    • SPIDErFL.training
    • SPIDErFL.update()
• aac_metrics.classes.spider_max module
  • SPIDErMax
    • SPIDErMax.compute()
    • SPIDErMax.extra_repr()
    • SPIDErMax.full_state_update
    • SPIDErMax.get_output_names()
    • SPIDErMax.higher_is_better
    • SPIDErMax.is_differentiable
    • SPIDErMax.max_value
    • SPIDErMax.min_value
    • SPIDErMax.reset()
    • SPIDErMax.training
    • SPIDErMax.update()
• aac_metrics.classes.vocab module
  • Vocab
    • Vocab.compute()
    • Vocab.full_state_update
    • Vocab.get_output_names()
    • Vocab.higher_is_better
    • Vocab.is_differentiable
    • Vocab.max_value
    • Vocab.min_value
    • Vocab.reset()
    • Vocab.training
    • Vocab.update()