lint(): fix lint errors

Author: AmitMY

signwriting_evaluation/metrics/base.py

@@ -59,15 +59,15 @@ def score_all(self, hypotheses: Sequence[str], references: Sequence[str], progre
     def score_self(self, hypotheses: Sequence[str], progress_bar=True) -> list[list[float]]:
         if not self.SYMMETRIC:
             return self.score_all(hypotheses, hypotheses, progress_bar)
-        
+
         # For symmetric metrics, only compute upper triangle to avoid redundant calculations
         n = len(hypotheses)
         scores = np.eye(n, dtype=np.float16)  # Initialize with diagonal 1
-        
+
         total = n * (n - 1) // 2  # Exclude diagonal
         iterator = tqdm([(i, j) for i in range(n) for j in range(i + 1, n)],
                         total=total, disable=not progress_bar or total == 1)
-        
+
         for i, j in iterator:
             score = self.score(hypotheses[i], hypotheses[j])
             scores[i][j] = scores[j][i] = score

signwriting_evaluation/metrics/bleu.py

@@ -2,7 +2,7 @@
 
 from signwriting.tokenizer import SignWritingTokenizer
 
-from signwriting_evaluation.metrics.base import SignWritingMetric
+from signwriting_evaluation.metrics.base import SignWritingMetric, validate_corpus_score_input
 
 
 class SignWritingBLEU(SignWritingMetric):
@@ -23,7 +23,7 @@ def score(self, hypothesis: str, reference: str) -> float:
         return self.bleu.sentence_score(hypothesis, [reference]).score / 100
 
     def corpus_score(self, hypotheses: list[str], references: list[list[str]]) -> float:
-        self.validate_corpus_score_input(hypotheses, references)
+        validate_corpus_score_input(hypotheses, references)
         hypotheses = [self.tokenize(h) for h in hypotheses]
         references = [[self.tokenize(r) for r in reference] for reference in references]
         return self.bleu.corpus_score(hypotheses, references).score / 100

signwriting_evaluation/metrics/chrf.py

@@ -1,6 +1,6 @@
 from sacrebleu.metrics import CHRF
 
-from signwriting_evaluation.metrics.base import SignWritingMetric
+from signwriting_evaluation.metrics.base import SignWritingMetric, validate_corpus_score_input
 
 
 class SignWritingCHRF(SignWritingMetric):
@@ -15,5 +15,5 @@ def score(self, hypothesis: str, reference: str) -> float:
         return self.chrf.sentence_score(hypothesis, [reference]).score / 100
 
     def corpus_score(self, hypotheses: list[str], references: list[list[str]]) -> float:
-        self.validate_corpus_score_input(hypotheses, references)
+        validate_corpus_score_input(hypotheses, references)
         return self.chrf.corpus_score(hypotheses, references).score / 100

signwriting_evaluation/metrics/similarity.py

@@ -35,7 +35,7 @@ def get_shape_class_index(shape: int) -> Optional[int]:
 
 
 @cache
-def text_to_signs(text: str) -> tuple[str]:
+def text_to_signs(text: str) -> tuple[str, ...]:
     text_as_fsw = swu2fsw(text)  # converts swu symbols to fsw, while keeping the fsw symbols if present
     return tuple(normalize_signwriting(text_as_fsw).split(" "))
 
@@ -49,70 +49,71 @@ def get_symbol_attributes(symbol: str) -> SymbolAttributes:
     return SymbolAttributes(shape, facing, angle, parallel)
 
 
+@cache
 def fast_positional_distance(pos1: Tuple[int, int], pos2: Tuple[int, int]) -> float:
     # Unbelievably, this is faster than using numpy or scipy for simple Euclidean distance
     # It reduces the overhead of converting to numpy arrays when calculating distances
     dx = pos1[0] - pos2[0]
     dy = pos1[1] - pos2[1]
     return math.sqrt(dx * dx + dy * dy)
 
+
+ERROR_WEIGHT = {
+    "shape": 5,  # same weight as switching parallelization
+    "facing": 5 / 3,  # more important than angle, not as much as shape and orientation
+    "angle": 5 / 24,  # lowest importance out of the criteria
+    "parallel": 5,  # parallelization is 3 columns compare to 1 for the facing direction
+    "positional": 1 / 10,  # may be big values
+    "normalized_factor": 1 / 2.5,  # fitting shape of function
+    "exp_factor": 1.5,  # exponential distribution
+    "class_penalty": 100,  # big penalty for each class type passed
+}
+
+
+@cache
+def fast_symbol_distance(attributes1: SymbolAttributes, attributes2: SymbolAttributes) -> float:
+    d_shape = (attributes1.shape - attributes2.shape) * ERROR_WEIGHT["shape"]
+    d_facing = (attributes1.facing - attributes2.facing) * ERROR_WEIGHT["facing"]
+    d_angle = (attributes1.angle - attributes2.angle) * ERROR_WEIGHT["angle"]
+    d_parallel = (attributes1.parallel != attributes2.parallel) * ERROR_WEIGHT["parallel"]
+    return math.sqrt(d_shape * d_shape + \
+                     d_facing * d_facing + \
+                     d_angle * d_angle + \
+                     d_parallel * d_parallel)
+
+
 fsw_to_sign = cache(fsw_to_sign)
 
+
 class SignWritingSimilarityMetric(SignWritingMetric):
     SYMMETRIC = True
 
     def __init__(self):
         super().__init__("SymbolsDistances")
-        self.weight = {
-            "shape": 5,  # same weight as switching parallelization
-            "facing": 5 / 3,  # more important than angle, not as much as shape and orientation
-            "angle": 5 / 24,  # lowest importance out of the criteria
-            "parallel": 5,  # parallelization is 3 columns compare to 1 for the facing direction
-            "positional": 1 / 10,  # may be big values
-            "normalized_factor": 1 / 2.5,  # fitting shape of function
-            "exp_factor": 1.5,  # exponential distribution
-            "class_penalty": 100,  # big penalty for each class type passed
-        }
-
         self.max_distance = self.calculate_distance({"symbol": "S10000", "position": (250, 250)},
                                                     {"symbol": "S38b07", "position": (750, 750)})
 
-    def weight_vector(self, attributes: SymbolAttributes) -> Tuple[float, ...]:
-        weighted_values = self.symbol_weight_vector * attributes
-        return weighted_values
-
-    @cache
-    def symbol_distance(self, attributes1: SymbolAttributes, attributes2: SymbolAttributes) -> float:
-        d_shape = (attributes1.shape - attributes2.shape) * self.weight["shape"]
-        d_facing = (attributes1.facing - attributes2.facing) * self.weight["facing"]
-        d_angle = (attributes1.angle - attributes2.angle) * self.weight["angle"]
-        d_parallel = (attributes1.parallel != attributes2.parallel) * self.weight["parallel"]
-        return math.sqrt(d_shape * d_shape + \
-                         d_facing * d_facing + \
-                         d_angle * d_angle + \
-                         d_parallel * d_parallel)
-
     def calculate_distance(self, hyp: SignSymbol, ref: SignSymbol) -> float:
         hyp_attributes = get_symbol_attributes(hyp['symbol'])
         ref_attributes = get_symbol_attributes(ref['symbol'])
 
-        symbols_distance = self.symbol_distance(hyp_attributes, ref_attributes)
+        symbols_distance = fast_symbol_distance(hyp_attributes, ref_attributes)
 
         position_euclidean = fast_positional_distance(hyp["position"], ref["position"])
-        position_distance = self.weight["positional"] * position_euclidean
+        position_distance = ERROR_WEIGHT["positional"] * position_euclidean
 
         hyp_class = get_shape_class_index(hyp_attributes.shape)
         ref_class = get_shape_class_index(ref_attributes.shape)
 
         if hyp_class is None or ref_class is None:
             return self.max_distance
 
-        class_penalty = abs(hyp_class - ref_class) * self.weight["class_penalty"]
+        class_penalty = abs(hyp_class - ref_class) * ERROR_WEIGHT["class_penalty"]
 
         return symbols_distance + position_distance + class_penalty
 
     def normalized_distance(self, unnormalized: float) -> float:
-        return pow(unnormalized / self.max_distance, self.weight["normalized_factor"])
+        return pow(unnormalized / self.max_distance, ERROR_WEIGHT["normalized_factor"])
 
     def symbols_score(self, hyp: SignSymbol, ref: SignSymbol) -> float:
         distance = self.calculate_distance(hyp, ref)
@@ -135,12 +136,10 @@ def error_rate(self, hyp: Sign, ref: Sign) -> float:
         cost_matrix = cost_matrix.reshape(len(hyp["symbols"]), -1)
         # Find the lowest cost matching
         row_ind, col_ind = linear_sum_assignment(cost_matrix)
-        pairs = list(zip(row_ind, col_ind))
-        # Print the matching and total cost
-        values = [cost_matrix[row, col] for row, col in pairs]
-        mean_cost = sum(values) / len(values)
+        mean_cost = float(cost_matrix[row_ind, col_ind].mean())
+
         length_error = self.length_acc(hyp, ref)
-        length_weight = pow(length_error, self.weight["exp_factor"])
+        length_weight = pow(length_error, ERROR_WEIGHT["exp_factor"])
         return length_weight + mean_cost * (1 - length_weight)
 
     def score_single_sign(self, hypothesis: str, reference: str) -> float:

signwriting_evaluation/metrics/test_similarity.py

@@ -17,8 +17,8 @@ def test_score(self):
     def test_score_is_symemtric(self):
         reference = "M519x534S37900497x466S3770b497x485S15a51491x501S22f03481x513"
         hypothesis = "M530x538S37602508x462S15a11493x494S20e00488x510S22f03469x517"
-        score1 = self.metric.score(hypothesis, reference)
-        score2 = self.metric.score(reference, hypothesis)
+        score1 = self.metric.score(hypothesis=hypothesis, reference=reference)
+        score2 = self.metric.score(hypothesis=reference, reference=hypothesis)
         self.assertAlmostEqual(score1, score2, msg="The metric is not symmetric")
 
     def test_score_jumbled_sign(self):