26 |
27 | Args |
|---|
28 |
29 |
30 | |
31 | example
32 | |
33 |
34 | The data used as query input.
35 | |
36 |
37 | |
38 | example_class
39 | |
40 |
41 | The class of the data used as query
42 | |
43 |
44 | |
45 | neighbors
46 | |
47 |
48 | The list of neighbors returned by the lookup()
49 | |
50 |
51 | |
52 | class_mapping
53 | |
54 |
55 | Mapping from class numerical ids to a class name. If not
56 | set, the plot will display the class numerical id instead.
57 | Defaults to None.
58 | |
59 |
60 | |
61 | fig_size
62 | |
63 |
64 | Size of the figure. Defaults to (24, 4).
65 | |
66 |
67 | |
68 | cmap
69 | |
70 |
71 | Default color scheme for black and white images e.g mnist.
72 | Defaults to 'viridis'.
73 | |
74 |
75 | |
76 | show
77 | |
78 |
79 | If the plot is going to be shown or not. Defaults to True.
80 | |
81 |
82 |
83 |
84 |
--------------------------------------------------------------------------------
/api/TFSimilarity/augmenters/Augmenter.md:
--------------------------------------------------------------------------------
1 | # TFSimilarity.augmenters.Augmenter
2 |
3 |
4 |
5 |
6 |
7 | Helper class that provides a standard way to create an ABC using
8 |
9 | Inherits From: [`ABC`](../../TFSimilarity/distances/ABC.md)
10 |
11 | inheritance.
12 |
13 | ## Methods
14 |
15 |
31 |
32 | Args |
|---|
33 |
34 |
35 | |
36 | embeddings
37 | |
38 |
39 | The embeddings outputed by the model that
40 | are to be visualized
41 | |
42 |
43 | |
44 | labels
45 | |
46 |
47 | Labels associated with the embeddings. If not supplied treat
48 | each example as its own classes.
49 | |
50 |
51 | |
52 | class_mapping
53 | |
54 |
55 | Dictionary or list that maps the class numerical ids
56 | to their name.
57 | |
58 |
59 | |
60 | images
61 | |
62 |
63 | Images to display in tooltip on hover. Usually x_test tensor.
64 | |
65 |
66 | |
67 | image_size
68 | |
69 |
70 | size of the images displayed in the tool tip.
71 | Defaults to 64.
72 | |
73 |
74 | |
75 | pt_size
76 | |
77 |
78 | Size of the points displayed on the visualization.
79 | Defaults to 3.
80 | |
81 |
82 | |
83 | tooltips_info
84 | |
85 |
86 | Dictionary of information to display in the tooltips.
87 | |
88 |
89 | |
90 | colorize
91 | |
92 |
93 | Colorize the clusters. Defaults to true.
94 | |
95 |
96 | |
97 | pastel_factor
98 | |
99 |
100 | Modify the color palette to be more pastel.
101 | |
102 |
103 | |
104 | densmap
105 | |
106 |
107 | Use UMAP dense mapper which provides better density
108 | estimation but is a little slower. Defaults to True.
109 | |
110 |
111 |
112 |
113 |
--------------------------------------------------------------------------------
/benchmark/supervised/components/experiments.py:
--------------------------------------------------------------------------------
1 | from __future__ import annotations
2 |
3 | import dataclasses
4 | import os
5 | from collections.abc import Mapping
6 | from itertools import product
7 | from typing import Any
8 |
9 | from tensorflow.keras.optimizers.schedules import LearningRateSchedule
10 |
11 | from . import datasets, utils
12 |
13 |
14 | @dataclasses.dataclass(eq=True, frozen=True)
15 | class Component:
16 | cid: str
17 | name: str
18 | params: Mapping[str, Any]
19 |
20 | def __hash__(self):
21 | return hash((self.cid, self.name))
22 |
23 |
24 | @dataclasses.dataclass
25 | class Experiment:
26 | run_grp: str
27 | path: str
28 | dataset: Component
29 | architecture: Component
30 | loss: Component
31 | opt: Component
32 | training: Component
33 | lr_schedule: LearningRateSchedule | None = None
34 |
35 |
36 | def make_experiments(cfg: Mapping[str, Any], output_dir: str) -> list[Experiment]:
37 | experiments = []
38 |
39 | # Generate the cross product of all the experiment params.
40 | for (dn, dcfg), (an, acfg), (ln, lcfg), (on, ocfg), tcfg in product(
41 | cfg["datasets"].items(),
42 | cfg["architectures"].items(),
43 | cfg["losses"].items(),
44 | cfg["optimizer"].items(),
45 | cfg["training"],
46 | ):
47 | dataset = datasets.utils.make_dataset_config(name=dn, params=dcfg)
48 | loss = Component(cid=lcfg["component"], name=ln, params=lcfg)
49 | opt = Component(cid=ocfg["component"], name=on, params=ocfg)
50 | training = Component(cid="", name=tcfg["name"], params=tcfg)
51 |
52 | for embedding_size in acfg.get("embedding_sizes", [128]):
53 | acfg["embedding"] = embedding_size
54 | architecture = Component(cid=acfg["component"], name=an, params=acfg)
55 |
56 | run_grp = utils.make_run_grp(
57 | dataset.name,
58 | architecture.name,
59 | architecture.params["embedding"],
60 | loss.name,
61 | opt.name,
62 | )
63 | experiments.append(
64 | Experiment(
65 | run_grp=run_grp,
66 | path=os.path.join(output_dir, run_grp),
67 | dataset=dataset,
68 | architecture=architecture,
69 | loss=loss,
70 | opt=opt,
71 | training=training,
72 | )
73 | )
74 | return experiments
75 |
--------------------------------------------------------------------------------
/tensorflow_similarity/samplers/file_samplers.py:
--------------------------------------------------------------------------------
1 | # Copyright 2021 The TensorFlow Authors
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | from __future__ import annotations
15 |
16 | from typing import TYPE_CHECKING, TypeVar
17 |
18 | import tensorflow as tf
19 |
20 | from .memory_samplers import MultiShotMemorySampler
21 |
22 | if TYPE_CHECKING:
23 | from collections.abc import Callable, Sequence
24 |
25 | from ..types import FloatTensor, IntTensor
26 | from .samplers import Augmenter
27 |
28 | T = TypeVar("T", FloatTensor, IntTensor)
29 |
30 |
31 | def load_image(path: str, target_size: tuple[int, int] | None = None) -> T:
32 | image_string = tf.io.read_file(path)
33 | image: T = tf.image.decode_jpeg(image_string, channels=3)
34 | image = tf.image.convert_image_dtype(image, tf.float32)
35 | if target_size:
36 | image = tf.image.resize(image, target_size, method=tf.image.ResizeMethod.LANCZOS3)
37 | image = tf.clip_by_value(image, 0.0, 1.0)
38 | return image
39 |
40 |
41 | class MultiShotFileSampler(MultiShotMemorySampler):
42 | def __init__(
43 | self,
44 | x,
45 | y,
46 | load_example_fn: Callable = load_image,
47 | classes_per_batch: int = 2,
48 | examples_per_class_per_batch: int = 2,
49 | steps_per_epoch: int = 1000,
50 | class_list: Sequence[int] | None = None,
51 | total_examples_per_class: int | None = None,
52 | augmenter: Augmenter | None = None,
53 | warmup: int = -1,
54 | ):
55 | super().__init__(
56 | x,
57 | y,
58 | load_example_fn=load_example_fn,
59 | classes_per_batch=classes_per_batch,
60 | examples_per_class_per_batch=examples_per_class_per_batch,
61 | steps_per_epoch=steps_per_epoch,
62 | class_list=class_list,
63 | total_examples_per_class=total_examples_per_class,
64 | augmenter=augmenter,
65 | warmup=warmup,
66 | )
67 |
--------------------------------------------------------------------------------
/tensorflow_similarity/distances/snr.py:
--------------------------------------------------------------------------------
1 | # Copyright 2021 The TensorFlow Authors
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | """Inner product similarity computation functions for embeddings."""
15 | from __future__ import annotations
16 |
17 | from typing import TYPE_CHECKING
18 |
19 | import tensorflow as tf
20 |
21 | if TYPE_CHECKING:
22 | from ..types import FloatTensor
23 |
24 | from .distance import Distance
25 |
26 |
27 | @tf.keras.utils.register_keras_serializable(package="Similarity")
28 | class SNRDistance(Distance):
29 | """
30 | Computes pairwise SNR distances between embeddings.
31 |
32 | The [Signal-to-Noise Ratio distance](https://arxiv.org/abs/1904.02616)
33 | is the ratio of noise variance to the feature variance.
34 | """
35 |
36 | def __init__(self, name: str = "snr", **kwargs):
37 | "Init SNR distance"
38 | super().__init__(name=name, **kwargs)
39 |
40 | @tf.function
41 | def call(self, query_embeddings: FloatTensor, key_embeddings: FloatTensor) -> FloatTensor:
42 | """Compute pairwise snr distances for a given batch of embeddings.
43 | SNR(i, j): anchor i and compared feature j
44 | SNR(i,j) may not be equal to SNR(j, i)
45 |
46 | Args:
47 | query_embeddings: Embeddings to compute the pairwise one.
48 |
49 | Returns:
50 | FloatTensor: Pairwise distance tensor.
51 | """
52 | # Calculating feature variance for each example
53 | anchor_var = tf.math.reduce_variance(query_embeddings, axis=1)
54 |
55 | # Calculating pairwise noise variances
56 | q_rs = tf.reshape(query_embeddings, shape=[tf.shape(query_embeddings)[0], -1])
57 | k_rs = tf.reshape(key_embeddings, shape=[tf.shape(key_embeddings)[0], -1])
58 | delta = tf.expand_dims(q_rs, axis=1) - tf.expand_dims(k_rs, axis=0)
59 | noise_var = tf.math.reduce_variance(delta, axis=2)
60 |
61 | distances: FloatTensor = tf.divide(noise_var, tf.expand_dims(anchor_var, axis=1))
62 |
63 | return distances
64 |
--------------------------------------------------------------------------------
/api/TFSimilarity/architectures/ResNet18Sim.md:
--------------------------------------------------------------------------------
1 | # TFSimilarity.architectures.ResNet18Sim
2 |
3 |
4 |
5 |
6 |
7 | Build an ResNet18 Model backbone for similarity learning
8 |
9 | ```python
10 | TFSimilarity.architectures.ResNet18Sim(
11 | input_shape: Tuple[int, int, int],
12 | embedding_size: int = 128,
13 | l2_norm: bool = True,
14 | include_top: bool = True,
15 | pooling: str = gem,
16 | gem_p=3.0
17 | ```
18 |
19 |
20 |
21 |
22 |
23 | Architecture from [Deep Residual Learning for Image Recognition](https://arxiv.org/abs/1512.03385)
24 |
25 |
26 |
27 |
28 | Args |
|---|
29 |
30 |
31 | |
32 | input_shape
33 | |
34 |
35 | Expected to be betweeen 32 and 224 and in the (H, W, C)
36 | data_format.
37 | |
38 |
39 | |
40 | embedding_size
41 | |
42 |
43 | Size of the output embedding. Usually between 64
44 | and 512. Defaults to 128.
45 | |
46 |
47 | |
48 | l2_norm
49 | |
50 |
51 | If True and include_top is also True, then
52 | tfsim.layers.MetricEmbedding is used as the last layer, otherwise
53 | keras.layers.Dense is used. This should be true when using cosine
54 | distance. Defaults to True.
55 | |
56 |
57 | |
58 | include_top
59 | |
60 |
61 | Whether to include a fully-connected layer of
62 | embedding_size at the top of the network. Defaults to True.
63 | |
64 |
65 | |
66 | pooling
67 | |
68 |
69 | Optional pooling mode for feature extraction when
70 | include_top is False. Defaults to gem.
71 | - None means that the output of the model will be the 4D tensor
72 | output of the last convolutional layer.
73 | - avg means that global average pooling will be applied to the
74 | output of the last convolutional layer, and thus the output of the
75 | model will be a 2D tensor.
76 | - max means that global max pooling will be applied.
77 | - gem means that global GeneralizedMeanPooling2D will be applied.
78 | The gem_p param sets the contrast amount on the pooling.
79 | |
80 |
81 | |
82 | gem_p
83 | |
84 |
85 | Sets the power in the GeneralizedMeanPooling2D layer. A value
86 | of 1.0 is equivelent to GlobalMeanPooling2D, while larger values
87 | will increase the contrast between activations within each feature
88 | map, and a value of math.inf will be equivelent to MaxPool2d.
89 | |
90 |
91 |
92 |
93 |
--------------------------------------------------------------------------------
/tensorflow_similarity/architectures/utils.py:
--------------------------------------------------------------------------------
1 | # Copyright 2021 The TensorFlow Authors
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | from __future__ import annotations
15 |
16 | import tensorflow as tf
17 |
18 |
19 | def convert_sync_batchnorm(model: tf.keras.Model) -> tf.keras.Model:
20 | """Replace BatchNormalization layers to SyncBatchNormalization in place.
21 | WARNINGS:
22 | * This function is tested only with efficientnet and resnet
23 | * The returned model has shared layers with the input one. One of them should be disposed.
24 | """
25 |
26 | layer2newtensor = {}
27 | in_ = tf.keras.layers.Input(model.input.shape[1:])
28 | layer2newtensor[model.input.name] = in_
29 | for layer in model.layers[1:]:
30 | assert len(layer.inbound_nodes) == 1
31 | if isinstance(layer.inbound_nodes[0].inbound_layers, list): # mutliple inputs
32 | x = [layer2newtensor[in_l.name] for in_l in layer.inbound_nodes[0].inbound_layers]
33 | else:
34 | x = layer2newtensor[layer.inbound_nodes[0].inbound_layers.name]
35 | if isinstance(layer, tf.keras.layers.BatchNormalization):
36 | tf_version = [int(v) for v in tf.__version__.split(".")]
37 | if tf_version[0] == 2 and tf_version[1] < 12:
38 | layer = tf.keras.layers.experimental.SyncBatchNormalization(**layer.get_config())
39 | else:
40 | layer = tf.keras.layers.BatchNormalization(**layer.get_config(), synchronized=True)
41 |
42 | if "truediv" in layer.name:
43 | # efficeientnet edge case
44 | # https://github.com/keras-team/keras/blob/v2.9.0/keras/applications/efficientnet.py#L334
45 | x = layer(x, layer.inbound_nodes[0]._flat_arguments[1])
46 | else:
47 | x = layer(x)
48 |
49 | layer2newtensor[layer.name] = x
50 | out_ = layer2newtensor[model.layers[-1].name]
51 | new_model = tf.keras.Model(inputs=in_, outputs=out_, name=model.name)
52 | new_model.set_weights(model.get_weights())
53 | return new_model
54 |
--------------------------------------------------------------------------------
/.github/workflows/nightly-publish.yml:
--------------------------------------------------------------------------------
1 | name: NightlyPublish
2 |
3 | on:
4 | workflow_dispatch: # Allow manual triggers
5 | schedule:
6 | # Runs every day at 3:07am UTC.
7 | - cron: '7 3 * * *'
8 |
9 | jobs:
10 | check:
11 |
12 | name: Check files
13 | # Prevent Publish from running on forks.
14 | if: github.repository == 'tensorflow/similarity'
15 | outputs:
16 | run_job: ${{ steps.check_files.outputs.run_job }}
17 | runs-on: ubuntu-latest
18 |
19 | steps:
20 | - uses: actions/checkout@v2
21 | with:
22 | fetch-depth: 2
23 | ref: 'development'
24 |
25 | - name: check modified files
26 | id: check_files
27 | run: |
28 | echo "=============== list modified files ==============="
29 | git diff --name-only HEAD^ HEAD
30 |
31 | echo "========== check paths of modified files =========="
32 | git diff --name-only HEAD^ HEAD > files.txt
33 | while IFS= read -r file
34 | do
35 | echo $file
36 | if [[ $file = tensorflow_similarity/* && $file != tensorflow_similarity/__init__.py ]]; then
37 | echo "This modified file is under the 'tensorflow_similarity' folder."
38 | echo "::set-output name=run_job::true"
39 | break
40 | else
41 | echo "::set-output name=run_job::false"
42 | fi
43 | done < files.txt
44 |
45 | publish:
46 |
47 | name: Publish nightly
48 | needs: check
49 | # Prevent Publish from running on forks.
50 | if: |
51 | github.repository == 'tensorflow/similarity' &&
52 | needs.check.outputs.run_job == 'true'
53 | runs-on: ubuntu-latest
54 |
55 | steps:
56 | - uses: actions/checkout@v2
57 | with:
58 | ref: 'development'
59 |
60 | - name: Set up Python
61 | uses: actions/setup-python@v2
62 | with:
63 | python-version: '3.9'
64 |
65 | - name: Install dependencies
66 | run: |
67 | python -m pip install --upgrade pip
68 |
69 | - name: Install package
70 | run: |
71 | pip install ".[tensorflow,dev]"
72 |
73 | - name: Increment dev version
74 | run: |
75 | # Increments the dev version and pushes the changes to development.
76 | python scripts/increment_version.py
77 |
78 | - name: Build package
79 | run: |
80 | python setup.py sdist bdist_wheel --project_name tfsim-nightly
81 |
82 | - name: Publish package
83 | run: |
84 | twine upload -u ${{ secrets.PYPI_NIGHTLY_USERNAME }} -p ${{ secrets.PYPI_NIGHTLY_TOKEN }} dist/* --verbose
85 |
--------------------------------------------------------------------------------
/tensorflow_similarity/distances/distance.py:
--------------------------------------------------------------------------------
1 | # Copyright 2021 The TensorFlow Authors
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | """Vectorized embedding pairwise distances computation functions"""
15 | from __future__ import annotations
16 |
17 | from abc import ABC, abstractmethod
18 | from typing import TYPE_CHECKING, Any
19 |
20 | if TYPE_CHECKING:
21 | from ..types import FloatTensor
22 |
23 |
24 | class Distance(ABC):
25 | """Abstract class for distance computation."""
26 |
27 | def __init__(self, name: str, **kwargs):
28 | self.name = name
29 |
30 | @abstractmethod
31 | def call(self, query_embeddings: FloatTensor, key_embeddings: FloatTensor) -> FloatTensor:
32 | """Compute pairwise distances for a given batch.
33 |
34 | Args:
35 | query_embeddings: Embeddings to compute the pairwise one.
36 | key_embeddings: Embeddings to compute the pairwise one.
37 |
38 | Returns:
39 | FloatTensor: Pairwise distance tensor.
40 | """
41 |
42 | def __call__(self, query_embeddings: FloatTensor, key_embeddings: FloatTensor):
43 | return self.call(query_embeddings, key_embeddings)
44 |
45 | def __str__(self) -> str:
46 | return self.name
47 |
48 | def get_config(self) -> dict[str, Any]:
49 | """Contains the distance configuration.
50 |
51 | Returns:
52 | A Python dict containing the configuration of the distance obj.
53 | """
54 | config = {"name": self.name}
55 |
56 | return config
57 |
58 | @classmethod
59 | def from_config(cls, config: dict[str, Any]) -> Distance:
60 | """Build a distance from a config.
61 |
62 | Args:
63 | config: A Python dict containing the configuration of the distance.
64 |
65 | Returns:
66 | A distance instance.
67 | """
68 | try:
69 | return cls(**config)
70 | except Exception as e:
71 | raise TypeError(
72 | f"Error when deserializing '{cls.__name__}' using" f"config={config}.\n\nException encountered: {e}"
73 | )
74 |
--------------------------------------------------------------------------------
/tests/losses/test_softnn_loss.py:
--------------------------------------------------------------------------------
1 | import tensorflow as tf
2 | from absl.testing import parameterized
3 | from tensorflow.keras.losses import Reduction
4 | from tensorflow.python.framework import combinations
5 |
6 | from tensorflow_similarity import losses
7 |
8 |
9 | @tf.function
10 | def softnn_util(y_true, x, temperature=1):
11 | """
12 | A simple loop based implementation of soft
13 | nearest neighbor loss to test the code.
14 | https://arxiv.org/pdf/1902.01889.pdf
15 | """
16 |
17 | batch_size = tf.shape(y_true)[0]
18 | loss = 0.0
19 | for i in tf.range(batch_size, dtype=tf.int32):
20 | numerator = 0.0
21 | denominator = 0.0
22 | for j in tf.range(batch_size, dtype=tf.int32):
23 | if i == j:
24 | continue
25 | if y_true[i] == y_true[j]:
26 | numerator += tf.math.exp(-1 * tf.math.reduce_sum(tf.math.square(x[i] - x[j])) / temperature)
27 | denominator += tf.math.exp(-1 * tf.math.reduce_sum(tf.math.square(x[i] - x[j])) / temperature)
28 | if numerator == 0.0:
29 | continue
30 | loss += tf.math.log(numerator / denominator)
31 | return -loss / tf.cast(batch_size, tf.float32)
32 |
33 |
34 | @combinations.generate(
35 | combinations.combine(
36 | mode=["graph", "eager"],
37 | )
38 | )
39 | class SoftNNLossTest(tf.test.TestCase, parameterized.TestCase):
40 | def test_config(self):
41 | softnn_obj = losses.SoftNearestNeighborLoss(
42 | reduction=Reduction.SUM,
43 | name="softnn_loss",
44 | distance="cosine",
45 | )
46 | self.assertEqual(softnn_obj.distance.name, "cosine")
47 | self.assertEqual(softnn_obj.name, "softnn_loss")
48 | self.assertEqual(softnn_obj.reduction, Reduction.SUM)
49 |
50 | @parameterized.parameters((0.1), (0.5), (1), (2), (5), (10), (50))
51 | def test_all_correct(self, temperature):
52 | num_inputs = 10
53 | n_classes = 10
54 |
55 | softnn_obj = losses.SoftNearestNeighborLoss(
56 | reduction=Reduction.SUM_OVER_BATCH_SIZE,
57 | temperature=temperature,
58 | )
59 |
60 | # y_true: labels
61 | y_true = tf.random.uniform((num_inputs, 1), 0, n_classes, dtype=tf.int32)
62 | # x: embeddings
63 | y_preds = tf.random.uniform((num_inputs, 20), 0, 1)
64 |
65 | loss = softnn_obj(y_true, y_preds)
66 | loss_check = softnn_util(
67 | y_true,
68 | y_preds,
69 | temperature,
70 | )
71 |
72 | loss_diff = loss - loss_check
73 | self.assertLess(self.evaluate(loss_diff), 1e-3)
74 |
--------------------------------------------------------------------------------
/tests/models/test_similarity_model.py:
--------------------------------------------------------------------------------
1 | # Copyright 2021 The TensorFlow Authors
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | import tensorflow as tf
15 |
16 | from tensorflow_similarity.losses import TripletLoss
17 | from tensorflow_similarity.models import SimilarityModel
18 |
19 |
20 | class SimilarityModelTest(tf.test.TestCase):
21 | # TODO(ovallis): Add tests for graph mode.
22 | def test_save_and_reload(self):
23 | out_dir = self.get_temp_dir()
24 |
25 | inputs = tf.keras.layers.Input(shape=(3,))
26 | outputs = tf.keras.layers.Dense(2)(inputs)
27 | model = SimilarityModel(inputs, outputs)
28 | model.compile(optimizer="adam", loss=TripletLoss())
29 |
30 | # index data
31 | x = tf.constant([[1, 1, 3], [3, 1, 2]], dtype="float32")
32 | y = tf.constant([1, 2])
33 | model.index(x, y)
34 |
35 | # save
36 | model.save(out_dir)
37 |
38 | # reload
39 | loaded_model = tf.keras.models.load_model(out_dir)
40 | loaded_model.load_index(out_dir)
41 | self.assertEqual(loaded_model._index.size(), len(y))
42 |
43 | def test_save_no_compile(self):
44 | out_dir = self.get_temp_dir()
45 |
46 | inputs = tf.keras.layers.Input(shape=(3,))
47 | outputs = tf.keras.layers.Dense(2)(inputs)
48 | model = SimilarityModel(inputs, outputs)
49 |
50 | model.save(out_dir)
51 | model2 = tf.keras.models.load_model(out_dir)
52 | self.assertIsInstance(model2, type(model))
53 |
54 | def test_index_single(self):
55 | """Unit Test for issues #161 & #162"""
56 | inputs = tf.keras.layers.Input(shape=(3,))
57 | outputs = tf.keras.layers.Dense(2)(inputs)
58 | model = SimilarityModel(inputs, outputs)
59 | model.compile(optimizer="adam", loss=TripletLoss())
60 |
61 | # index data
62 | x = tf.constant([1, 1, 3], dtype="float32")
63 | y = tf.constant([1])
64 |
65 | # run individual sample & index
66 | model.index_single(x, y, data=x)
67 | self.assertEqual(model._index.size(), 1)
68 |
69 |
70 | if __name__ == "__main__":
71 | tf.test.main()
72 |
--------------------------------------------------------------------------------
/tests/retrieval_metrics/test_map_at_k.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import tensorflow as tf
3 |
4 | from tensorflow_similarity.retrieval_metrics import MapAtK
5 |
6 |
7 | def test_concrete_instance():
8 | rm = MapAtK(r={1: 4, 0: 4})
9 |
10 | assert rm.name == "map@5"
11 | # Check the name once we have updated the threshold
12 | rm.distance_threshold = 0.1
13 | assert rm.name == "map@5 : distance_threshold@0.1"
14 | assert repr(rm) == "map@k : map@5 : distance_threshold@0.1"
15 | assert rm.canonical_name == "map@k"
16 | assert rm.k == 5
17 | assert rm.distance_threshold == 0.1
18 | assert rm.average == "micro"
19 |
20 | expected_config = {
21 | "r": {1: 4, 0: 4},
22 | "name": "map@5 : distance_threshold@0.1",
23 | "canonical_name": "map@k",
24 | "clip_at_r": False,
25 | "k": 5,
26 | "distance_threshold": 0.1,
27 | }
28 | assert rm.get_config() == expected_config
29 |
30 |
31 | def test_compute():
32 | query_labels = tf.constant([1, 1, 1, 0])
33 | match_mask = tf.constant(
34 | [
35 | [True, True, False],
36 | [True, True, False],
37 | [True, True, False],
38 | [False, False, True],
39 | ],
40 | dtype=bool,
41 | )
42 | rm = MapAtK(r={0: 10, 1: 3}, k=3)
43 |
44 | mapk = rm.compute(query_labels=query_labels, match_mask=match_mask)
45 |
46 | # mapk should be sum(precision@k*Relevancy_Mask)/R
47 | # class 1 has 3 results sets that are all T,T,F:
48 | # (1.0*True+1.0*True+0.66*False)/3 = 0.66667
49 | # class 0 has 1 result set that is F,F,T
50 | # (0.0*False+0.0*False+0.33*True)/10 = 0.03332
51 | # mapk = (0.667*3 + 0.0332)/4
52 | expected = tf.constant(0.50833333332)
53 |
54 | np.testing.assert_allclose(mapk, expected)
55 |
56 |
57 | def test_clip_at_r():
58 | query_labels = tf.constant([0, 1])
59 | match_mask = tf.constant(
60 | [
61 | [False, False, False, True],
62 | [False, False, False, True],
63 | ],
64 | dtype=bool,
65 | )
66 | rm = MapAtK(r={0: 4, 1: 3}, k=4, clip_at_r=True)
67 |
68 | mapk = rm.compute(query_labels=query_labels, match_mask=match_mask)
69 |
70 | # mapk should be sum(precision@k*Relevancy_Mask)/R
71 | # but here we clip the result set at the r associate with the query label.
72 | # class 0 has 1 result set of F,F,F,T with R == 4
73 | # (0.0*False+0.0*False+0.0*False)/3 = 0.0
74 | # class 1 has 1 result set of F,F,F,T with R == 3
75 | # (0.0*False+0.0*False+0.0*False+0.25*True)/4 = 0.0625
76 | # mapk = (0.0 + 0.0625)/2
77 | expected = tf.constant(0.03125)
78 |
79 | np.testing.assert_allclose(mapk, expected)
80 |
--------------------------------------------------------------------------------
/tests/stores/test_cached.py:
--------------------------------------------------------------------------------
1 | import os
2 |
3 | import numpy as np
4 |
5 | from tensorflow_similarity.stores.cached import CachedStore
6 |
7 |
8 | def build_store(records, path):
9 | kv_store = CachedStore(path=path)
10 | idxs = []
11 | for r in records:
12 | idx = kv_store.add(r[0], r[1], r[2])
13 | idxs.append(idx)
14 | return kv_store, idxs
15 |
16 |
17 | def test_cached_store_and_retrieve(tmp_path):
18 | records = [[[0.1, 0.2], 1, [0, 0, 0]], [[0.2, 0.3], 2, [0, 0, 0]]]
19 |
20 | kv_store, idxs = build_store(records, tmp_path)
21 |
22 | # check index numbering
23 | for gt, idx in enumerate(idxs):
24 | assert isinstance(idx, int)
25 | assert gt == idx
26 |
27 | # check reference counting
28 | assert kv_store.size() == 2
29 |
30 | # get back three elements
31 | for idx in idxs:
32 | emb, lbl, dt = kv_store.get(idx)
33 | assert emb == records[idx][0]
34 | assert lbl == records[idx][1]
35 | assert dt == records[idx][2]
36 |
37 |
38 | def test_reset(tmp_path):
39 | records = [[[0.1, 0.2], 1, [0, 0, 0]], [[0.2, 0.3], 2, [0, 0, 0]]]
40 |
41 | kv_store, idxs = build_store(records, tmp_path)
42 |
43 | # check reference counting
44 | assert kv_store.size() == 2
45 |
46 | kv_store.reset()
47 | assert kv_store.size() == 0
48 |
49 | kv_store.add(records[0][0], records[0][1], records[0][2])
50 | assert kv_store.size() == 1
51 |
52 |
53 | def test_batch_add(tmp_path):
54 | embs = np.array([[0.1, 0.2], [0.2, 0.3]])
55 | lbls = np.array([1, 2])
56 | data = np.array([[0, 0, 0], [1, 1, 1]])
57 |
58 | kv_store = CachedStore(path=tmp_path)
59 | idxs = kv_store.batch_add(embs, lbls, data)
60 | for idx in idxs:
61 | emb, lbl, dt = kv_store.get(idx)
62 | assert np.array_equal(emb, embs[idx])
63 | assert np.array_equal(lbl, lbls[idx])
64 | assert np.array_equal(dt, data[idx])
65 |
66 |
67 | def test_save_and_reload(tmp_path):
68 | records = [[[0.1, 0.2], 1, [0, 0, 0]], [[0.2, 0.3], 2, [0, 0, 0]]]
69 |
70 | save_path = tmp_path / "save"
71 | os.mkdir(save_path)
72 | obj_path = tmp_path / "obj"
73 | os.mkdir(obj_path)
74 |
75 | kv_store, idxs = build_store(records, obj_path)
76 | kv_store.save(save_path)
77 |
78 | # reload
79 | reloaded_store = CachedStore()
80 | print(f"loading from {save_path}")
81 | reloaded_store.load(save_path)
82 |
83 | assert reloaded_store.size() == 2
84 |
85 | # get back three elements
86 | for idx in idxs:
87 | emb, lbl, dt = reloaded_store.get(idx)
88 | assert np.array_equal(emb, records[idx][0])
89 | assert np.array_equal(lbl, records[idx][1])
90 | assert np.array_equal(dt, records[idx][2])
91 |
--------------------------------------------------------------------------------
/api/TFSimilarity/distances/Distance.md:
--------------------------------------------------------------------------------
1 | # TFSimilarity.distances.Distance
2 |
3 |
4 |
5 |
6 |
7 | Note: don't forget to add your distance to the DISTANCES list
8 |
9 | Inherits From: [`ABC`](../../TFSimilarity/distances/ABC.md)
10 |
11 |
12 | ```python
13 | TFSimilarity.distances.Distance(
14 | name: str, aliases: List[str] = []
15 | )
16 | ```
17 |
18 |
19 |
20 |
21 | and add alias names in it.
22 |
23 | ## Methods
24 |
25 |
27 |
28 | Args |
|---|
29 |
30 |
31 | |
32 | queries
33 | |
34 |
35 | Test examples that will be tested against the built index.
36 | |
37 |
38 | |
39 | query_labels
40 | |
41 |
42 | Queries nearest neighbors expected labels.
43 | |
44 |
45 | |
46 | targets
47 | |
48 |
49 | Examples that are indexed.
50 | |
51 |
52 | |
53 | target_labels
54 | |
55 |
56 | Target examples labels.
57 | |
58 |
59 | |
60 | known_classes
61 | |
62 |
63 | The set of classes seen during training.
64 | |
65 |
66 | |
67 | distance
68 | |
69 |
70 | Distance function used to compute pairwise distance
71 | between examples embeddings.
72 | |
73 |
74 | |
75 | metrics
76 | |
77 |
78 | List of
79 | 'tf.similarity.classification_metrics.ClassificationMetric()` to
80 | compute during the evaluation. Defaults to ['binary_accuracy',
81 | 'f1score'].
82 | |
83 |
84 | |
85 | tb_logdir
86 | |
87 |
88 | Where to write TensorBoard logs. Defaults to None.
89 | |
90 |
91 | |
92 | k
93 | |
94 |
95 | The number of nearest neighbors to return for each query.
96 | The lookups are consumed by the Matching Strategy and used to
97 | derive the matching label and distance.
98 | |
99 |
100 | |
101 | matcher
102 | |
103 |
104 | 'match_nearest', 'match_majority_vote' or
105 | ClassificationMatch object. Defines the classification matching,
106 | e.g., match_nearest will count a True Positive if the query_label
107 | is equal to the label of the nearest neighbor and the distance is
108 | less than or equal to the distance threshold.
109 | |
110 |
111 | |
112 | distance_thresholds
113 | |
114 |
115 | A 1D tensor denoting the distances points at
116 | which we compute the metrics. If None, distance_thresholds is set
117 | to tf.constant([math.inf])
118 | |
119 |
120 |
121 |
122 |
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | tmp/
2 | tmp.py
3 | tensorflow_similarity.egg-info/
4 | logs/
5 | examples/models/
6 | examples/logs/
7 | .vscode/
8 | site/
9 | release.sh
10 | .DS_Store
11 | benchmark/supervised/datasets/
12 | benchmark/supervised/models/
13 | datasets/
14 | multi_modal_datasets/
15 | *.h5
16 |
17 | # Byte-compiled / optimized / DLL files
18 | __pycache__/
19 | *.py[cod]
20 |
21 | *$py.class
22 | *.prof
23 | # C extensions
24 | *.so
25 |
26 | # Distribution / packaging
27 | .Python
28 | build/
29 | develop-eggs/
30 | dist/
31 | downloads/
32 | eggs/
33 | .eggs/
34 | lib/
35 | lib64/
36 | parts/
37 | sdist/
38 | var/
39 | wheels/
40 | pip-wheel-metadata/
41 | share/python-wheels/
42 | *.egg-info/
43 | .installed.cfg
44 | *.egg
45 | MANIFEST
46 |
47 | # PyInstaller
48 | # Usually these files are written by a python script from a template
49 | # before PyInstaller builds the exe, so as to inject date/other infos into it.
50 | *.manifest
51 | *.spec
52 |
53 | # Installer logs
54 | pip-log.txt
55 | pip-delete-this-directory.txt
56 |
57 | # Unit test / coverage reports
58 | htmlcov/
59 | .tox/
60 | .nox/
61 | .coverage
62 | .coverage.*
63 | .cache
64 | nosetests.xml
65 | coverage.xml
66 | *.cover
67 | *.py,cover
68 | .hypothesis/
69 | .pytest_cache/
70 | .pytype
71 |
72 | # Translations
73 | *.mo
74 | *.pot
75 |
76 | # Django stuff:
77 | *.log
78 | local_settings.py
79 | db.sqlite3
80 | db.sqlite3-journal
81 |
82 | # Flask stuff:
83 | instance/
84 | .webassets-cache
85 |
86 | # Scrapy stuff:
87 | .scrapy
88 |
89 | # Sphinx documentation
90 | docs/_build/
91 |
92 | # PyBuilder
93 | target/
94 |
95 | # Jupyter Notebook
96 | .ipynb_checkpoints
97 |
98 | # IPython
99 | profile_default/
100 | ipython_config.py
101 |
102 | # pyenv
103 | .python-version
104 |
105 | # pipenv
106 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
107 | # However, in case of collaboration, if having platform-specific dependencies or dependencies
108 | # having no cross-platform support, pipenv may install dependencies that don't work, or not
109 | # install all needed dependencies.
110 | #Pipfile.lock
111 |
112 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow
113 | __pypackages__/
114 |
115 | # Celery stuff
116 | celerybeat-schedule
117 | celerybeat.pid
118 |
119 | # SageMath parsed files
120 | *.sage.py
121 |
122 | # Environments
123 | .env
124 | .venv
125 | env/
126 | venv/
127 | ENV/
128 | env.bak/
129 | venv.bak/
130 |
131 | # Spyder project settings
132 | .spyderproject
133 | .spyproject
134 |
135 | # Rope project settings
136 | .ropeproject
137 |
138 | # mkdocs documentation
139 | /site
140 |
141 | # mypy
142 | .mypy_cache/
143 | .dmypy.json
144 | dmypy.json
145 |
146 | # Pyre type checker
147 | .pyre/
148 |
149 | # Pipfile
150 | Pipfile
151 | Pipfile.lock
152 |
--------------------------------------------------------------------------------
/tensorflow_similarity/losses/metric_loss.py:
--------------------------------------------------------------------------------
1 | # Copyright 2020 The TensorFlow Authors. All Rights Reserved.
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | # ==============================================================================
15 | """Metric losses base class."""
16 | from __future__ import annotations
17 |
18 | from typing import TYPE_CHECKING, Any
19 |
20 | import tensorflow as tf
21 |
22 | if TYPE_CHECKING:
23 | from collections.abc import Callable
24 | from ..types import FloatTensor
25 |
26 | from ..utils import is_tensor_or_variable
27 |
28 |
29 | class MetricLoss(tf.keras.losses.Loss):
30 | """Wraps a loss function in the `Loss` class."""
31 |
32 | def __init__(
33 | self, fn: Callable, reduction: Callable = tf.keras.losses.Reduction.AUTO, name: str | None = None, **kwargs
34 | ):
35 | """Initializes `LossFunctionWrapper` class.
36 | Args:
37 | fn: The loss function to wrap, with signature `fn(y_true, y_pred,
38 | **kwargs)`.
39 | reduction: (Optional) Type of `tf.keras.losses.Reduction` to apply to
40 | loss. Default value is `AUTO`.
41 | name: (Optional) name for the loss.
42 | **kwargs: The keyword arguments that are passed on to `fn`.
43 | """
44 | super().__init__(reduction=reduction, name=name)
45 | self.fn = fn
46 | self._fn_kwargs = kwargs
47 |
48 | def call(self, y_true: FloatTensor, y_pred: FloatTensor) -> FloatTensor:
49 | """Invokes the `LossFunctionWrapper` instance.
50 | Args:
51 | y_true: Ground truth values.
52 | y_pred: The predicted values.
53 | Returns:
54 | Loss values per sample.
55 | """
56 | loss: FloatTensor = self.fn(y_true, y_pred, y_true, y_pred, **self._fn_kwargs)
57 | return loss
58 |
59 | def get_config(self) -> dict[str, Any]:
60 | """Contains the loss configuration.
61 |
62 | Returns:
63 | A Python dict containing the configuration of the loss.
64 | """
65 | config: dict[str, Any] = super().get_config()
66 | for k, v in iter(self._fn_kwargs.items()):
67 | if is_tensor_or_variable(v):
68 | config[k] = tf.keras.backend.eval(v)
69 | else:
70 | config[k] = v
71 |
72 | return config
73 |
--------------------------------------------------------------------------------
/tensorflow_similarity/classification_metrics/recall.py:
--------------------------------------------------------------------------------
1 | # Copyright 2021 The TensorFlow Authors
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | from __future__ import annotations
15 |
16 | from typing import TYPE_CHECKING
17 |
18 | import tensorflow as tf
19 |
20 | if TYPE_CHECKING:
21 | from ..types import FloatTensor
22 |
23 | from .classification_metric import ClassificationMetric
24 |
25 |
26 | class Recall(ClassificationMetric):
27 | """Calculates the recall of the query classification.
28 |
29 | Computes the recall given the query classification counts.
30 |
31 | $$
32 | Recall = \frac{\textrm{true_positives}}{\textrm{true_positives} +
33 | \textrm{false_negatives}}
34 | $$
35 |
36 | args:
37 | name: Name associated with a specific metric object, e.g.,
38 | recall@0.1
39 |
40 | Usage with `tf.similarity.models.SimilarityModel()`:
41 |
42 | ```python
43 | model.calibrate(x=query_examples,
44 | y=query_labels,
45 | calibration_metric='recall')
46 | ```
47 | """
48 |
49 | def __init__(self, name: str = "recall") -> None:
50 | super().__init__(name=name, canonical_name="recall")
51 |
52 | def compute(self, tp: FloatTensor, fp: FloatTensor, tn: FloatTensor, fn: FloatTensor, count: int) -> FloatTensor:
53 | """Compute the classification metric.
54 |
55 | The `compute()` method supports computing the metric for a set of
56 | values, where each value represents the counts at a specific distance
57 | threshold.
58 |
59 | Args:
60 | tp: A 1D FloatTensor containing the count of True Positives at each
61 | distance threshold.
62 |
63 | fp: A 1D FloatTensor containing the count of False Positives at
64 | each distance threshold.
65 |
66 | tn: A 1D FloatTensor containing the count of True Negatives at each
67 | distance threshold.
68 |
69 | fn: A 1D FloatTensor containing the count of False Negatives at
70 | each distance threshold.
71 |
72 | count: The total number of queries
73 |
74 | Returns:
75 | A 1D FloatTensor containing the metric at each distance threshold.
76 | """
77 | result: FloatTensor = tf.math.divide_no_nan(tp, tp + fn)
78 | return result
79 |
--------------------------------------------------------------------------------
/tensorflow_similarity/classification_metrics/negative_predictive_value.py:
--------------------------------------------------------------------------------
1 | # Copyright 2021 The TensorFlow Authors
2 | #
3 | # Licensed under the Apache License, Version 2.0 (the "License");
4 | # you may not use this file except in compliance with the License.
5 | # You may obtain a copy of the License at
6 | #
7 | # http://www.apache.org/licenses/LICENSE-2.0
8 | #
9 | # Unless required by applicable law or agreed to in writing, software
10 | # distributed under the License is distributed on an "AS IS" BASIS,
11 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | # See the License for the specific language governing permissions and
13 | # limitations under the License.
14 | from __future__ import annotations
15 |
16 | from typing import TYPE_CHECKING
17 |
18 | import tensorflow as tf
19 |
20 | if TYPE_CHECKING:
21 | from ..types import FloatTensor
22 |
23 | from .classification_metric import ClassificationMetric
24 |
25 |
26 | class NegativePredictiveValue(ClassificationMetric):
27 | """Calculates the negative predictive value of the query classification.
28 |
29 | Computes the NPV given the query classification counts.
30 |
31 | $$
32 | FPR = \frac{\textrm{true_negatives}}{\textrm{false_negatives} +
33 | \textrm{true_negatives}}
34 | $$
35 |
36 | args:
37 | name: Name associated with a specific metric object, e.g.
38 | npv@0.1
39 |
40 | Usage with `tf.similarity.models.SimilarityModel()`:
41 |
42 | ```python
43 | model.calibrate(x=query_examples,
44 | y=query_labels,
45 | calibration_metric='fpr')
46 | ```
47 | """
48 |
49 | def __init__(self, name: str = "npv") -> None:
50 | super().__init__(name=name, canonical_name="negative_predictive_value")
51 |
52 | def compute(self, tp: FloatTensor, fp: FloatTensor, tn: FloatTensor, fn: FloatTensor, count: int) -> FloatTensor:
53 | """Compute the classification metric.
54 |
55 | The `compute()` method supports computing the metric for a set of
56 | values, where each value represents the counts at a specific distance
57 | threshold.
58 |
59 | Args:
60 | tp: A 1D FloatTensor containing the count of True Positives at each
61 | distance threshold.
62 |
63 | fp: A 1D FloatTensor containing the count of False Positives at
64 | each distance threshold.
65 |
66 | tn: A 1D FloatTensor containing the count of True Negatives at each
67 | distance threshold.
68 |
69 | fn: A 1D FloatTensor containing the count of False Negatives at
70 | each distance threshold.
71 |
72 | count: The total number of queries
73 |
74 | Returns:
75 | A 1D FloatTensor containing the metric at each distance threshold.
76 | """
77 | result: FloatTensor = tf.math.divide_no_nan(tn, tn + fn)
78 | return result
79 |
--------------------------------------------------------------------------------
/tests/retrieval_metrics/test_retrieval_metric.py:
--------------------------------------------------------------------------------
1 | import re
2 |
3 | import pytest
4 | import tensorflow as tf
5 |
6 | from tensorflow_similarity.retrieval_metrics import RetrievalMetric
7 | from tensorflow_similarity.types import BoolTensor, FloatTensor, IntTensor
8 |
9 |
10 | class ConcreteRetrievalMetric(RetrievalMetric):
11 | def compute(
12 | self,
13 | *, # keyword only arguments see PEP-570
14 | query_labels: IntTensor,
15 | lookup_labels: IntTensor,
16 | lookup_distances: FloatTensor,
17 | match_mask: BoolTensor,
18 | ) -> FloatTensor:
19 | return tf.constant(1.0)
20 |
21 |
22 | def test_concrete_instance():
23 | rm = ConcreteRetrievalMetric(
24 | name="foo",
25 | canonical_name="bar",
26 | k=6,
27 | average="macro",
28 | )
29 |
30 | assert rm.name == "foo@6"
31 | # Check the name once we have updated the threshold
32 | rm.distance_threshold = 0.1
33 | assert rm.name == "foo@6 : distance_threshold@0.1"
34 | assert repr(rm) == "bar : foo@6 : distance_threshold@0.1"
35 | assert rm.canonical_name == "bar"
36 | assert rm.k == 6
37 | assert rm.distance_threshold == 0.1
38 | assert rm.average == "macro"
39 |
40 | expected_config = {
41 | "name": "foo@6 : distance_threshold@0.1",
42 | "canonical_name": "bar",
43 | "k": 6,
44 | "distance_threshold": 0.1,
45 | }
46 | assert rm.get_config() == expected_config
47 |
48 |
49 | def test_k_greater_than_num_lookups():
50 | query_labels = tf.constant([1, 1])
51 | match_mask = tf.constant(
52 | [
53 | [True, True, False, False],
54 | [True, False, False, True],
55 | ],
56 | dtype=bool,
57 | )
58 | rm = ConcreteRetrievalMetric(
59 | name="foo",
60 | canonical_name="bar",
61 | k=5,
62 | average="macro",
63 | )
64 |
65 | msg = "The number of neighbors must be >= K. Number of neighbors is 4 but " "K is 5."
66 |
67 | with pytest.raises(ValueError, match=re.escape(msg)):
68 | _ = rm._check_shape(query_labels=query_labels, match_mask=match_mask)
69 |
70 |
71 | def test_query_and_match_mask_different_dims():
72 | query_labels = tf.constant([1, 2, 3, 4])
73 | match_mask = tf.constant(
74 | [
75 | [True, True, False, False],
76 | [True, False, False, True],
77 | ],
78 | dtype=bool,
79 | )
80 | rm = ConcreteRetrievalMetric(
81 | name="foo",
82 | canonical_name="bar",
83 | k=4,
84 | average="macro",
85 | )
86 |
87 | msg = (
88 | "The number of lookup sets must equal the number of query labels. "
89 | "Number of lookup sets is 2 but the number of query labels is 4."
90 | )
91 |
92 | with pytest.raises(ValueError, match=re.escape(msg)):
93 | _ = rm._check_shape(query_labels=query_labels, match_mask=match_mask)
94 |
--------------------------------------------------------------------------------
/api/TFSimilarity/distances/SNRDistance.md:
--------------------------------------------------------------------------------
1 | # TFSimilarity.distances.SNRDistance
2 |
3 |
4 |
5 |
6 |
7 | Computes pairwise SNR distances between embeddings.
8 |
9 | Inherits From: [`Distance`](../../TFSimilarity/distances/Distance.md), [`ABC`](../../TFSimilarity/distances/ABC.md)
10 |
11 | ```python
12 | TFSimilarity.distances.SNRDistance()
13 | ```
14 |
15 |
16 |
17 |
18 |
19 | The [Signal-to-Noise Ratio distance](https://arxiv.org/abs/1904.02616)
20 | is the ratio of noise variance to the feature variance.
21 |
22 | ## Methods
23 |
24 |