tf-models-nightly 2.17.0.dev20240408__py2.py3-none-any.whl → 2.17.0.dev20240410__py2.py3-none-any.whl

official/recommendation/uplift/metrics/loss_metric.py

@@ -40,7 +40,7 @@ class LossMetric(tf_keras.metrics.Metric):
   ...     true_logits=tf.constant([1, 2, 3, 4])
   ...     is_treatment=tf.constant([True, False, True, False]),
   ... )
-  >>> sliced_loss(y_true=tf.zeros(4), y_pred=y_pred)
+  >>> sliced_loss(y_true=y_true, y_pred=y_pred)
   {
       "loss": 2.5
       "loss/control": 4.0
@@ -58,8 +58,11 @@ class LossMetric(tf_keras.metrics.Metric):
 
   def __init__(
       self,
-      loss_fn: Callable[[tf.Tensor, tf.Tensor], tf.Tensor],
+      loss_fn: (
+          Callable[[tf.Tensor, tf.Tensor], tf.Tensor] | tf_keras.metrics.Metric
+      ),
       from_logits: bool = True,
+      slice_by_treatment: bool = True,
       name: str = "loss",
       dtype: tf.DType = tf.float32,
       **loss_fn_kwargs,
@@ -67,27 +70,61 @@ class LossMetric(tf_keras.metrics.Metric):
     """Initializes the instance.
 
     Args:
-      loss_fn: The loss function to apply between the targets and model outputs,
-        with signature `loss_fn(y_true, y_pred, **loss_fn_kwargs)`.
+      loss_fn: The loss function or Keras metric to apply with call signature
+        `__call__(y_true: tf,Tensor, y_pred: tf.Tensor, **loss_fn_kwargs)`. Note
+        that the `loss_fn_kwargs` will not be passed to the `__call__` method if
+        `loss_fn` is a Keras metric.
       from_logits: Specifies whether the true logits or true predictions should
         be used from the model outputs to compute the loss. Defaults to using
         the true logits.
-      name: Optional name for the instance.
-      dtype: Optional data type for the instance.
+      slice_by_treatment: Specifies whether the loss should be sliced by the
+        treatment indicator tensor. If `True`, `loss_fn` will be wrapped in a
+        `TreatmentSlicedMetric` to report the loss values sliced by the
+        treatment group.
+      name: Optional name for the instance. If `loss_fn` is a Keras metric then
+        its name will be used instead.
+      dtype: Optional data type for the instance. If `loss_fn` is a Keras metric
+        then its `dtype` will be used instead.
       **loss_fn_kwargs: The keyword arguments that are passed on to `loss_fn`.
+        These arguments will be ignored if `loss_fn` is a Keras metric.
     """
+    # Do not accept Loss objects as they reduce tensors before weighting.
+    if isinstance(loss_fn, tf_keras.losses.Loss):
+      raise TypeError(
+          "`loss_fn` cannot be a Keras `Loss` object, pass a non-reducing loss"
+          " function or a metric instance instead."
+      )
+
+    if isinstance(loss_fn, tf_keras.metrics.Metric):
+      name = loss_fn.name
+      dtype = loss_fn.dtype
+
     super().__init__(name=name, dtype=dtype)
 
     self._loss_fn = loss_fn
     self._from_logits = from_logits
     self._loss_fn_kwargs = loss_fn_kwargs
+    self._slice_by_treatment = slice_by_treatment
+
+    if isinstance(loss_fn, tf_keras.metrics.Metric):
+      metric_from_logits = loss_fn.get_config().get("from_logits", from_logits)
+      if from_logits != metric_from_logits:
+        raise ValueError(
+            f"Value passed to `from_logits` ({from_logits}) is conflicting with"
+            " the `from_logits` value passed to the `loss_fn` metric"
+            f" ({metric_from_logits}). Ensure that they have the same value."
+        )
+      loss_metric = loss_fn
 
-    if "from_logits" in inspect.signature(loss_fn).parameters:
-      self._loss_fn_kwargs.update({"from_logits": from_logits})
+    else:
+      if "from_logits" in inspect.signature(loss_fn).parameters:
+        self._loss_fn_kwargs.update({"from_logits": from_logits})
+      loss_metric = tf_keras.metrics.Mean(name=name, dtype=dtype)
 
-    self._treatment_sliced_loss = treatment_sliced_metric.TreatmentSlicedMetric(
-        tf_keras.metrics.Mean(name=name, dtype=dtype)
-    )
+    if slice_by_treatment:
+      self._loss = treatment_sliced_metric.TreatmentSlicedMetric(loss_metric)
+    else:
+      self._loss = loss_metric
 
   def update_state(
       self,
@@ -115,24 +152,34 @@ class LossMetric(tf_keras.metrics.Metric):
           f" {type(y_pred)} instead."
       )
 
-    if self._from_logits:
-      loss = self._loss_fn(y_true, y_pred.true_logits)
-    else:
-      loss = self._loss_fn(y_true, y_pred.true_predictions)
+    pred = y_pred.true_logits if self._from_logits else y_pred.true_predictions
 
-    self._treatment_sliced_loss.update_state(
-        values=loss,
-        is_treatment=y_pred.is_treatment,
-        sample_weight=sample_weight,
-    )
+    is_treatment = {}
+    if self._slice_by_treatment:
+      is_treatment["is_treatment"] = y_pred.is_treatment
+
+    if isinstance(self._loss_fn, tf_keras.metrics.Metric):
+      self._loss.update_state(
+          y_true,
+          y_pred=pred,
+          sample_weight=sample_weight,
+          **is_treatment,
+      )
+    else:
+      self._loss.update_state(
+          values=self._loss_fn(y_true, pred, **self._loss_fn_kwargs),
+          sample_weight=sample_weight,
+          **is_treatment,
+      )
 
-  def result(self) -> dict[str, tf.Tensor]:
-    return self._treatment_sliced_loss.result()
+  def result(self) -> tf.Tensor | dict[str, tf.Tensor]:
+    return self._loss.result()
 
   def get_config(self) -> dict[str, Any]:
     config = super().get_config()
     config["loss_fn"] = tf_keras.utils.serialize_keras_object(self._loss_fn)
     config["from_logits"] = self._from_logits
+    config["slice_by_treatment"] = self._slice_by_treatment
     config.update(self._loss_fn_kwargs)
     return config
 
@@ -141,4 +188,4 @@ class LossMetric(tf_keras.metrics.Metric):
     config["loss_fn"] = tf_keras.utils.deserialize_keras_object(
         config["loss_fn"]
     )
-    return LossMetric(**config)
+    return cls(**config)

official/recommendation/uplift/metrics/loss_metric_test.py

@@ -25,9 +25,7 @@ from official.recommendation.uplift import types
 from official.recommendation.uplift.metrics import loss_metric
 
 
-class TrueLogitsTreatmentLossTest(
-    keras_test_case.KerasTestCase, parameterized.TestCase
-):
+class LossMetricTest(keras_test_case.KerasTestCase, parameterized.TestCase):
 
   def _get_outputs(
       self,
@@ -64,6 +62,20 @@ class TrueLogitsTreatmentLossTest(
               "loss/treatment": 1.0,
           },
       },
+      {
+          "testcase_name": "unweighted_metric",
+          "loss_fn": tf_keras.metrics.MeanSquaredError(name="loss"),
+          "from_logits": False,
+          "y_true": tf.constant([[0], [0], [2], [2]]),
+          "y_pred": tf.constant([[1], [2], [3], [4]]),
+          "is_treatment": tf.constant([[True], [False], [True], [False]]),
+          "sample_weight": None,
+          "expected_losses": {
+              "loss": 2.5,
+              "loss/control": 4.0,
+              "loss/treatment": 1.0,
+          },
+      },
       {
           "testcase_name": "weighted",
           "loss_fn": tf_keras.losses.mean_absolute_error,
@@ -78,6 +90,20 @@ class TrueLogitsTreatmentLossTest(
               "loss/treatment": 1.0,
           },
       },
+      {
+          "testcase_name": "weighted_keras_metric",
+          "loss_fn": tf_keras.metrics.MeanAbsoluteError(name="loss"),
+          "from_logits": False,
+          "y_true": tf.constant([[0], [0], [2], [7]]),
+          "y_pred": tf.constant([[1], [2], [3], [4]]),
+          "is_treatment": tf.constant([[True], [False], [True], [False]]),
+          "sample_weight": tf.constant([[0.5], [0.5], [0.7], [1.8]]),
+          "expected_losses": {
+              "loss": np.average([1, 2, 1, 3], weights=[0.5, 0.5, 0.7, 1.8]),
+              "loss/control": np.average([2, 3], weights=[0.5, 1.8]),
+              "loss/treatment": 1.0,
+          },
+      },
       {
           "testcase_name": "only_control",
           "loss_fn": tf_keras.metrics.mean_squared_error,
@@ -92,6 +118,20 @@ class TrueLogitsTreatmentLossTest(
               "loss/treatment": 0.0,
           },
       },
+      {
+          "testcase_name": "only_control_metric",
+          "loss_fn": tf_keras.metrics.MeanSquaredError(name="loss"),
+          "from_logits": False,
+          "y_true": tf.constant([[0], [1], [5]]),
+          "y_pred": tf.constant([[1], [2], [5]]),
+          "is_treatment": tf.constant([[False], [False], [False]]),
+          "sample_weight": tf.constant([1, 0, 1]),
+          "expected_losses": {
+              "loss": 0.5,
+              "loss/control": 0.5,
+              "loss/treatment": 0.0,
+          },
+      },
       {
           "testcase_name": "only_treatment",
           "loss_fn": tf_keras.metrics.mean_absolute_error,
@@ -106,6 +146,20 @@ class TrueLogitsTreatmentLossTest(
               "loss/treatment": 0.5,
           },
       },
+      {
+          "testcase_name": "only_treatment_metric",
+          "loss_fn": tf_keras.metrics.MeanAbsoluteError(name="loss"),
+          "from_logits": False,
+          "y_true": tf.constant([[0], [1], [5]]),
+          "y_pred": tf.constant([[1], [2], [5]]),
+          "is_treatment": tf.constant([[True], [True], [True]]),
+          "sample_weight": tf.constant([1, 0, 1]),
+          "expected_losses": {
+              "loss": 0.5,
+              "loss/control": 0.0,
+              "loss/treatment": 0.5,
+          },
+      },
       {
           "testcase_name": "one_entry",
           "loss_fn": tf.nn.log_poisson_loss,
@@ -138,6 +192,70 @@ class TrueLogitsTreatmentLossTest(
               "loss/treatment": 0.0,
           },
       },
+      {
+          "testcase_name": "no_entry_metric",
+          "loss_fn": tf_keras.metrics.BinaryCrossentropy(name="loss"),
+          "from_logits": False,
+          "y_true": tf.constant([[]]),
+          "y_pred": tf.constant([[]]),
+          "is_treatment": tf.constant([[]]),
+          "sample_weight": tf.constant([[]]),
+          "expected_losses": {
+              "loss": 0.0,
+              "loss/control": 0.0,
+              "loss/treatment": 0.0,
+          },
+      },
+      {
+          "testcase_name": "auc_metric",
+          "loss_fn": tf_keras.metrics.AUC(from_logits=True, name="loss"),
+          "from_logits": True,
+          "y_true": tf.constant([[0], [0], [1], [1]]),
+          "y_pred": tf.constant([[0], [0.5], [0.3], [0.9]]),
+          "is_treatment": tf.constant([[1], [1], [1], [1]]),
+          "sample_weight": None,
+          "expected_losses": {
+              "loss": 0.75,
+              "loss/control": 0.0,
+              "loss/treatment": 0.75,
+          },
+      },
+      {
+          "testcase_name": "loss_fn_with_from_logits",
+          "loss_fn": tf_keras.losses.binary_crossentropy,
+          "from_logits": True,
+          "y_true": tf.constant([[0.0, 1.0]]),
+          "y_pred": tf.constant([[0.0, 1.0]]),
+          "is_treatment": tf.constant([[0], [0]]),
+          "sample_weight": None,
+          "expected_losses": {
+              "loss": 0.50320446,
+              "loss/control": 0.50320446,
+              "loss/treatment": 0.0,
+          },
+      },
+      {
+          "testcase_name": "no_treatment_slice",
+          "loss_fn": tf_keras.losses.binary_crossentropy,
+          "from_logits": True,
+          "y_true": tf.constant([[0.0, 1.0]]),
+          "y_pred": tf.constant([[0.0, 1.0]]),
+          "is_treatment": tf.constant([[0], [0]]),
+          "sample_weight": None,
+          "expected_losses": 0.50320446,
+          "slice_by_treatment": False,
+      },
+      {
+          "testcase_name": "no_treatment_slice_metric",
+          "loss_fn": tf_keras.metrics.BinaryCrossentropy(from_logits=False),
+          "from_logits": False,
+          "y_true": tf.constant([[0.0, 1.0]]),
+          "y_pred": tf.constant([[0.0, 1.0]]),
+          "is_treatment": tf.constant([[0], [0]]),
+          "sample_weight": None,
+          "expected_losses": 0,
+          "slice_by_treatment": False,
+      },
   )
   def test_metric_computes_sliced_losses(
       self,
@@ -147,7 +265,8 @@ class TrueLogitsTreatmentLossTest(
       y_pred: tf.Tensor,
       is_treatment: tf.Tensor,
       sample_weight: tf.Tensor | None,
-      expected_losses: dict[str, float],
+      expected_losses: float | dict[str, float],
+      slice_by_treatment: bool = True,
   ):
     if from_logits:
       true_logits = y_pred
@@ -156,7 +275,11 @@ class TrueLogitsTreatmentLossTest(
       true_logits = tf.zeros_like(y_pred)  # Irrelevant for testing.
       true_predictions = y_pred
 
-    metric = loss_metric.LossMetric(loss_fn=loss_fn, from_logits=from_logits)
+    metric = loss_metric.LossMetric(
+        loss_fn=loss_fn,
+        from_logits=from_logits,
+        slice_by_treatment=slice_by_treatment,
+    )
     outputs = self._get_outputs(
         true_logits=true_logits,
         true_predictions=true_predictions,
@@ -237,9 +360,27 @@ class TrueLogitsTreatmentLossTest(
     metric.reset_states()
     self.assertEqual(expected_initial_result, metric.result())
 
-  def test_metric_is_configurable(self):
+  @parameterized.product(
+      loss_fn=(
+          tf_keras.losses.binary_crossentropy,
+          tf_keras.metrics.BinaryCrossentropy(
+              from_logits=True, name="bce_loss"
+          ),
+      ),
+      slice_by_treatment=(True, False),
+  )
+  def test_metric_is_configurable(
+      self,
+      loss_fn: (
+          Callable[[tf.Tensor, tf.Tensor], tf.Tensor] | tf_keras.metrics.Metric
+      ),
+      slice_by_treatment: bool,
+  ):
     metric = loss_metric.LossMetric(
-        tf_keras.losses.binary_crossentropy, from_logits=True, name="bce_loss"
+        loss_fn,
+        from_logits=True,
+        slice_by_treatment=slice_by_treatment,
+        name="bce_loss",
     )
     self.assertLayerConfigurable(
         layer=metric,
@@ -261,6 +402,19 @@ class TrueLogitsTreatmentLossTest(
     ):
       metric.update_state(y_true=tf.ones((3, 1)), y_pred=tf.ones((3, 1)))
 
+  def test_passing_loss_object_raises_error(self):
+    with self.assertRaisesRegex(
+        TypeError, "`loss_fn` cannot be a Keras `Loss` object"
+    ):
+      loss_metric.LossMetric(loss_fn=tf_keras.losses.MeanAbsoluteError())
+
+  def test_conflicting_from_logits_values_raises_error(self):
+    with self.assertRaises(ValueError):
+      loss_metric.LossMetric(
+          loss_fn=tf_keras.metrics.BinaryCrossentropy(from_logits=True),
+          from_logits=False,
+      )
+
 
 if __name__ == "__main__":
   tf.test.main()

official/vision/dataloaders/retinanet_input.py

@@ -39,11 +39,11 @@ class Parser(parser.Parser):
 
   def __init__(self,
                output_size,
-               min_level,
+               min_level: int | None,
                max_level,
-               num_scales,
-               aspect_ratios,
-               anchor_size,
+               num_scales: int | None,
+               aspect_ratios: list[float] | None,
+               anchor_size: float | None,
                match_threshold=0.5,
                unmatched_threshold=0.5,
                box_coder_weights=None,
@@ -63,20 +63,28 @@ class Parser(parser.Parser):
                keep_aspect_ratio=True):
     """Initializes parameters for parsing annotations in the dataset.
 
+    If one provides `input_anchor` when calling `_parse_eval_data()` and
+    `_parse_train_data()`, the `min_level`, `num_scales`, `aspect_ratios`, and
+    `anchor_size` can be `None`.
+
     Args:
       output_size: `Tensor` or `list` for [height, width] of output image. The
         output_size should be divided by the largest feature stride 2^max_level.
       min_level: `int` number of minimum level of the output feature pyramid.
+        Can be `None` if `input_anchor` is provided in `_parse_*_data()`.
       max_level: `int` number of maximum level of the output feature pyramid.
       num_scales: `int` number representing intermediate scales added on each
         level. For instances, num_scales=2 adds one additional intermediate
-        anchor scales [2^0, 2^0.5] on each level.
+        anchor scales [2^0, 2^0.5] on each level. Can be `None` if
+        `input_anchor` is provided in `_parse_*_data()`.
       aspect_ratios: `list` of float numbers representing the aspect ratio
         anchors added on each level. The number indicates the ratio of width to
         height. For instances, aspect_ratios=[1.0, 2.0, 0.5] adds three anchors
-        on each scale level.
+        on each scale level. Can be `None` if `input_anchor` is provided in
+        `_parse_*_data()`.
       anchor_size: `float` number representing the scale of size of the base
-        anchor to the feature stride 2^level.
+        anchor to the feature stride 2^level. Can be `None` if `input_anchor` is
+        provided in `_parse_*_data()`.
       match_threshold: `float` number between 0 and 1 representing the
         lower-bound threshold to assign positive labels for anchors. An anchor
         with a score over the threshold is labeled positive.

{tf_models_nightly-2.17.0.dev20240408.dist-info → tf_models_nightly-2.17.0.dev20240410.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tf-models-nightly
-Version: 2.17.0.dev20240408
+Version: 2.17.0.dev20240410
 Summary: TensorFlow Official Models
 Home-page: https://github.com/tensorflow/models
 Author: Google Inc.

{tf_models_nightly-2.17.0.dev20240408.dist-info → tf_models_nightly-2.17.0.dev20240410.dist-info}/RECORD

@@ -912,8 +912,8 @@ official/recommendation/uplift/metrics/label_mean.py,sha256=ECaes7FZmsksnwySn7jf
 official/recommendation/uplift/metrics/label_mean_test.py,sha256=b_d3lNlpkDm2xKLUkxfiXeQg7pjL8HNx7y9NaYarpV0,7083
 official/recommendation/uplift/metrics/label_variance.py,sha256=9DCl42BJkehxfWD3pSbZnRNvwfhVM6VyHwivGdaU72s,3610
 official/recommendation/uplift/metrics/label_variance_test.py,sha256=k0mdEU1WU53-HIEO5HGtfp1MleifD-h4bZNKtTvM3Ws,7681
-official/recommendation/uplift/metrics/loss_metric.py,sha256=8GAcqehBgHVz0TZn6obRhyQlLhz_-jmIpP0EAvJLBYI,4870
-official/recommendation/uplift/metrics/loss_metric_test.py,sha256=IwbWd6PQOYG4uGzobWNxP2Mh6PrVTEcFV_-6GGxaJTU,9346
+official/recommendation/uplift/metrics/loss_metric.py,sha256=qWMcLk1JmLkru5T9qcqO2UbB_AJQKjQ8uUSAxjR1l58,6883
+official/recommendation/uplift/metrics/loss_metric_test.py,sha256=QIUujZvUud-A2itI2vs2KpzWfLwbq2XDd9H9CFq5D4Y,14929
 official/recommendation/uplift/metrics/metric_configs.py,sha256=Z-r79orE4EycQ5TJ7xdI5LhjOHT3wzChYyDxcxGqLXk,1670
 official/recommendation/uplift/metrics/sliced_metric.py,sha256=O2I2apZK6IfOQK9Q_mgSiTUCnGokczp4e14zrrYNeRU,8564
 official/recommendation/uplift/metrics/sliced_metric_test.py,sha256=dhY41X8lqT_WW04XLjyjDerZwujEBGeTXtxf4NkYThw,11359
@@ -987,7 +987,7 @@ official/vision/dataloaders/input_reader.py,sha256=CHojw8PJKf74jl8Q3rtH2ylwhmTYg
 official/vision/dataloaders/input_reader_factory.py,sha256=WpvSA8qyqAo3wkmme4WqXpICBVg0SuR6_nNWHZ0ECM0,1623
 official/vision/dataloaders/maskrcnn_input.py,sha256=iCc08yYD-7mvIPojgBjm_nSvoQACXWCIeZNZN8CfXSs,16822
 official/vision/dataloaders/parser.py,sha256=nMXnhigMa_ascSJ2OK88xi4HdE9xvfL3G4oMrHau-t4,2315
-official/vision/dataloaders/retinanet_input.py,sha256=joxJL4hQVPw-FW5iUc7RsxP60N7iYGRuVFpU3gC5flE,18291
+official/vision/dataloaders/retinanet_input.py,sha256=bU1fDpJuOtBZVJSg3Fzaku2PjxHh22E4d3M7B3Vu8ZQ,18831
 official/vision/dataloaders/segmentation_input.py,sha256=Klg5KAChYZDRvqzZfyIzdPy54rTlWYZp2AotolD3WX8,12934
 official/vision/dataloaders/tf_example_decoder.py,sha256=9yCT6uSLMpmw50w7zdaRR_BXy6vIvliLZntrYAgzD18,8647
 official/vision/dataloaders/tf_example_decoder_test.py,sha256=PHxneXHn5-eIMdmk1uI4IPLa178kTCifa4EF53ik2Jo,12629
@@ -1203,9 +1203,9 @@ tensorflow_models/__init__.py,sha256=etxw45SHxuwFCRX5qGxGMP83II0JfJulzNl5GSNJvhw
 tensorflow_models/tensorflow_models_test.py,sha256=AxUYUdiQn416UR7jg0h6rmv688esvlKDfpyDCIQkF18,1395
 tensorflow_models/nlp/__init__.py,sha256=4tA5Pf4qaFwT-fIFOpX7x7FHJpnyJT-5UgOeFYTyMlc,807
 tensorflow_models/vision/__init__.py,sha256=zBorY_v5xva1uI-qxhZO3Qh-Dii-Suq6wEYh6hKHDfc,833
-tf_models_nightly-2.17.0.dev20240408.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
-tf_models_nightly-2.17.0.dev20240408.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
-tf_models_nightly-2.17.0.dev20240408.dist-info/METADATA,sha256=ZfIoWf-Y-2LFztes6-vBXDsnvSy86Bb-ZAEF6o1Vpi8,1432
-tf_models_nightly-2.17.0.dev20240408.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-tf_models_nightly-2.17.0.dev20240408.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
-tf_models_nightly-2.17.0.dev20240408.dist-info/RECORD,,
+tf_models_nightly-2.17.0.dev20240410.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
+tf_models_nightly-2.17.0.dev20240410.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
+tf_models_nightly-2.17.0.dev20240410.dist-info/METADATA,sha256=Bh56e1__Pn_yvpm9QMq4h12nKucvnKAftuk0ElQqn_w,1432
+tf_models_nightly-2.17.0.dev20240410.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+tf_models_nightly-2.17.0.dev20240410.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
+tf_models_nightly-2.17.0.dev20240410.dist-info/RECORD,,