xax 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

xax/__init__.py

@@ -12,7 +12,7 @@ and running the update script:
     python -m scripts.update_api --inplace
 """
 
-__version__ = "0.3.7"
+__version__ = "0.3.9"
 
 # This list shouldn't be modified by hand; instead, run the update script.
 __all__ = [
@@ -31,6 +31,10 @@ __all__ = [
     "TransformerBlock",
     "TransformerCache",
     "TransformerStack",
+    "Categorical",
+    "Distribution",
+    "MixtureOfGaussians",
+    "Normal",
     "FourierEmbeddings",
     "IdentityPositionalEmbeddings",
     "LearnedPositionalEmbeddings",
@@ -219,6 +223,10 @@ NAME_MAP: dict[str, str] = {
     "TransformerBlock": "nn.attention",
     "TransformerCache": "nn.attention",
     "TransformerStack": "nn.attention",
+    "Categorical": "nn.distributions",
+    "Distribution": "nn.distributions",
+    "MixtureOfGaussians": "nn.distributions",
+    "Normal": "nn.distributions",
     "FourierEmbeddings": "nn.embeddings",
     "IdentityPositionalEmbeddings": "nn.embeddings",
     "LearnedPositionalEmbeddings": "nn.embeddings",
@@ -405,6 +413,7 @@ if IMPORT_ALL or TYPE_CHECKING:
         TransformerCache,
         TransformerStack,
     )
+    from xax.nn.distributions import Categorical, Distribution, MixtureOfGaussians, Normal
     from xax.nn.embeddings import (
         EmbeddingKind,
         FourierEmbeddings,

xax/nn/distributions.py

@@ -0,0 +1,181 @@
+"""Defines some probability distribution helper functions.
+
+In general, it is preferrable to use Distrax or another library, but we wanted
+to have a simple interface of our own so that we can quickly upgrade Jax
+versions (since Distrax is tied pretty closely to Tensorflow).
+"""
+
+__all__ = [
+    "Distribution",
+    "Categorical",
+    "Normal",
+    "MixtureOfGaussians",
+]
+
+from abc import ABC, abstractmethod
+
+import jax
+import jax.numpy as jnp
+from jaxtyping import Array, PRNGKeyArray
+
+
+class Distribution(ABC):
+    @abstractmethod
+    def log_prob(self, x: Array) -> Array: ...
+
+    @abstractmethod
+    def sample(self, key: PRNGKeyArray) -> Array: ...
+
+    @abstractmethod
+    def mode(self) -> Array: ...
+
+    @abstractmethod
+    def entropy(self) -> Array: ...
+
+
+class Categorical(Distribution):
+    def __init__(self, logits_n: Array) -> None:
+        self.logits_n = logits_n
+
+    @property
+    def num_categories(self) -> int:
+        return self.logits_n.shape[-1]
+
+    def log_prob(self, x: Array) -> Array:
+        """Compute log probability for specific categories.
+
+        Args:
+            x: Array of category indices
+
+        Returns:
+            Log probabilities for the given categories
+        """
+        log_probs = jax.nn.log_softmax(self.logits_n, axis=-1)
+        # Use advanced indexing to get the log probabilities for the given categories
+        return log_probs[x]
+
+    def sample(self, key: PRNGKeyArray) -> Array:
+        return jax.random.categorical(key, self.logits_n, axis=-1)
+
+    def mode(self) -> Array:
+        return self.logits_n.argmax(axis=-1)
+
+    def entropy(self) -> Array:
+        """Compute entropy of the categorical distribution."""
+        probs = jax.nn.softmax(self.logits_n, axis=-1)
+        log_probs = jax.nn.log_softmax(self.logits_n, axis=-1)
+        return -jnp.sum(probs * log_probs, axis=-1)
+
+
+class Normal(Distribution):
+    def __init__(self, loc: Array, scale: Array) -> None:
+        self.loc = loc
+        self.scale = scale
+
+    def log_prob(self, x: Array) -> Array:
+        return -0.5 * jnp.log(2 * jnp.pi) - jnp.log(self.scale) - (x - self.loc) ** 2 / (2 * self.scale**2)
+
+    def sample(self, key: PRNGKeyArray) -> Array:
+        return self.loc + self.scale * jax.random.normal(key, self.loc.shape)
+
+    def mode(self) -> Array:
+        return self.loc
+
+    def entropy(self) -> Array:
+        return jnp.log(2 * jnp.pi * jnp.e) + jnp.log(self.scale)
+
+
+class MixtureOfGaussians(Distribution):
+    def __init__(self, means_nm: Array, stds_nm: Array, logits_nm: Array) -> None:
+        """Initialize a mixture of Gaussians.
+
+        Args:
+            means_nm: Array of shape (..., n_components) containing means
+            stds_nm: Array of shape (..., n_components) containing standard deviations
+            logits_nm: Array of shape (..., n_components) containing mixing logits
+        """
+        self.means_nm = means_nm
+        self.stds_nm = stds_nm
+        self.logits_nm = logits_nm
+
+    def log_prob(self, x: Array) -> Array:
+        """Compute log probability of the mixture.
+
+        Args:
+            x: Array of shape (...,) containing values to evaluate
+
+        Returns:
+            Log probabilities of shape (...,)
+        """
+        # Expand x to match component dimensions
+        x_expanded = x[..., None]  # Shape: (..., 1)
+
+        # Compute log probabilities for each component
+        component_log_probs = (
+            -0.5 * jnp.log(2 * jnp.pi)
+            - jnp.log(self.stds_nm)
+            - (x_expanded - self.means_nm) ** 2 / (2 * self.stds_nm**2)
+        )
+
+        # Compute mixing weights
+        mixing_logits = jax.nn.log_softmax(self.logits_nm, axis=-1)
+
+        # Combine using log-sum-exp trick for numerical stability
+        return jax.scipy.special.logsumexp(component_log_probs + mixing_logits, axis=-1)
+
+    def sample(self, key: PRNGKeyArray) -> Array:
+        """Sample from the mixture of Gaussians.
+
+        Args:
+            key: PRNG key
+
+        Returns:
+            Samples of shape (...,) where ... are the batch dimensions
+        """
+        # Sample component indices
+        component_key, sample_key = jax.random.split(key)
+        component_indices = jax.random.categorical(component_key, self.logits_nm, axis=-1)
+
+        # Sample from selected components using advanced indexing
+        # We need to handle the case where we have batch dimensions
+        batch_shape = self.means_nm.shape[:-1]  # All dimensions except the last (components)
+
+        # Reshape for easier indexing
+        means_flat = self.means_nm.reshape(-1, self.means_nm.shape[-1])
+        stds_flat = self.stds_nm.reshape(-1, self.stds_nm.shape[-1])
+        indices_flat = component_indices.reshape(-1)
+
+        # Get selected means and stds
+        selected_means = means_flat[jnp.arange(len(indices_flat)), indices_flat]
+        selected_stds = stds_flat[jnp.arange(len(indices_flat)), indices_flat]
+
+        # Generate random noise
+        noise = jax.random.normal(sample_key, selected_means.shape)
+
+        # Reshape back to original batch shape
+        samples = selected_means + selected_stds * noise
+        return samples.reshape(batch_shape)
+
+    def mode(self) -> Array:
+        """Return the mode of the mixture (approximate - returns mean of highest weight component)."""
+        mixing_weights = jax.nn.softmax(self.logits_nm, axis=-1)
+        max_weight_idx = jnp.argmax(mixing_weights, axis=-1)
+
+        # Use advanced indexing to get the means of the highest weight components
+        batch_shape = self.means_nm.shape[:-1]
+        means_flat = self.means_nm.reshape(-1, self.means_nm.shape[-1])
+        indices_flat = max_weight_idx.reshape(-1)
+
+        selected_means = means_flat[jnp.arange(len(indices_flat)), indices_flat]
+        return selected_means.reshape(batch_shape)
+
+    def entropy(self) -> Array:
+        """Compute entropy of the mixture (approximate)."""
+        mixing_weights = jax.nn.softmax(self.logits_nm, axis=-1)
+        component_entropies = jnp.log(2 * jnp.pi * jnp.e) + jnp.log(self.stds_nm)
+
+        # Weighted sum of component entropies plus mixing entropy
+        weighted_entropies = jnp.sum(mixing_weights * component_entropies, axis=-1)
+        mixing_entropy = -jnp.sum(mixing_weights * jnp.log(mixing_weights + 1e-8), axis=-1)
+
+        return weighted_entropies + mixing_entropy

xax/task/mixins/data_loader.py

@@ -110,7 +110,12 @@ class DataloadersMixin(ProcessMixin[Config], BaseTask[Config], Generic[Config],
             "or `get_data_iterator` to return an iterator for the given dataset."
         )
 
-    def get_dataloader(self, dataset: Dataset[T, Tc_co], phase: Phase) -> Dataloader[T, Tc_co]:
+    def get_dataloader(
+        self,
+        dataset: Dataset[T, Tc_co],
+        phase: Phase,
+        prefetch_factor: int | None = None,
+    ) -> Dataloader[T, Tc_co]:
         debugging = self.config.debug_dataloader
         if debugging:
             logger.warning("Parallel dataloaders disabled in debugging mode")
@@ -135,7 +140,7 @@ class DataloadersMixin(ProcessMixin[Config], BaseTask[Config], Generic[Config],
             dataset=dataset,
             batch_size=self.config.batch_size,
             num_workers=0 if debugging else cfg.num_workers,
-            prefetch_factor=cfg.prefetch_factor,
+            prefetch_factor=cfg.prefetch_factor if prefetch_factor is None else prefetch_factor,
             mp_manager=self.multiprocessing_manager,
             dataloader_worker_init_fn=self.dataloader_worker_init_fn,
             collate_worker_init_fn=self.collate_worker_init_fn,

xax/task/mixins/train.py

@@ -60,7 +60,7 @@ from xax.utils.experiments import (
     get_state_file_string,
     get_training_code,
 )
-from xax.utils.jax import jit as xax_jit
+from xax.utils.jax import jit as xax_jit, scan as xax_scan
 from xax.utils.logging import LOG_PING, LOG_STATUS
 from xax.utils.pytree import get_pytree_param_count
 from xax.utils.text import highlight_exception_message, show_info
@@ -175,6 +175,7 @@ class TrainConfig(
     valid_first_n_seconds: float | None = field(60.0, help="Run first validation after N seconds")
     max_steps: int | None = field(None, help="Maximum number of steps to run")
     step_kind: str = field("step", help=f"How to measure a step; one of [{', '.join(get_args(StepKind))}]")
+    updates_per_step: int = field(1, help="Number of updates to perform per step")
     random_seed: int = field(1337, help="Random seed for the task")
     global_grad_clip: float = field(value=10.0, help="The maximum gradient norm to clip to.")
 
@@ -597,6 +598,7 @@ class TrainMixin(
         metrics = self.compute_metrics(model, batch, output, loss, state)
         return loss, (output, metrics)
 
+    @xax_jit(static_argnames=["self", "model_static", "optimizer"], jit_level=3)
     def update(
         self,
         model_arr: PyTree,
@@ -609,44 +611,9 @@ class TrainMixin(
         grad_fn = jax.grad(self.get_output_and_loss, argnums=0, has_aux=True)
         grad_fn = xax_jit(static_argnums=[1], jit_level=3)(grad_fn)
         grads, (output, metrics) = grad_fn(model_arr, model_static, batch, state)
-        model_arr, opt_state, grad_metrics = self.apply_gradients_with_clipping(model_arr, grads, optimizer, opt_state)
-        return model_arr, opt_state, output, metrics | grad_metrics
-
-    @xax_jit(static_argnames=["self", "optimizer"], jit_level=3)
-    def apply_gradients_with_clipping(
-        self,
-        model_arr: PyTree,
-        grads: PyTree,
-        optimizer: optax.GradientTransformation,
-        opt_state: optax.OptState,
-    ) -> tuple[PyTree, optax.OptState, dict[str, Array]]:
-        grad_norm = optax.global_norm(grads)
-        grad_metrics = {"grad_norm": grad_norm}
-
-        def apply(grads: PyTree, grad_norm: Array) -> tuple[PyTree, optax.OptState]:
-            # Clip gradients based on global norm, similar to optax.clip_by_global_norm
-            trigger = jnp.squeeze(grad_norm < self.config.global_grad_clip)
-
-            def clip_fn(t: Array) -> Array:
-                return jax.lax.select(trigger, t, (t / grad_norm.astype(t.dtype)) * self.config.global_grad_clip)
-
-            grads = jax.tree.map(clip_fn, grads)
-
-            # Apply the gradient updates.
-            updates, new_opt_state = optimizer.update(grads, opt_state, model_arr)
-            new_model_arr = eqx.apply_updates(model_arr, updates)
-            return new_model_arr, new_opt_state
-
-        # Don't apply updates if the gradient is NaN or Inf.
-        new_model_arr, new_opt_state = jax.lax.cond(
-            jnp.isnan(grad_norm) | jnp.isinf(grad_norm),
-            lambda *_: (model_arr, opt_state),
-            apply,
-            grads,
-            grad_norm,
-        )
-
-        return new_model_arr, new_opt_state, grad_metrics
+        updates, opt_state = optimizer.update(grads, opt_state, model_arr)
+        model_arr = eqx.apply_updates(model_arr, updates)
+        return model_arr, opt_state, output, metrics
 
     def get_size_of_batch(self, batch: Batch) -> int | None:
         """Gets the batch size for the current batch.
@@ -729,11 +696,36 @@ class TrainMixin(
         model_static: PyTree,
         optimizer: optax.GradientTransformation,
         opt_state: optax.OptState,
-        batch: Batch,
+        batches: Batch,
         state: State,
     ) -> tuple[PyTree, optax.OptState, Output, FrozenDict[str, Array]]:
-        model_arr, opt_state, output, metrics = self.update(model_arr, model_static, optimizer, opt_state, batch, state)
-        return model_arr, opt_state, output, FrozenDict(metrics)
+        def update_fn(
+            carry: tuple[PyTree, optax.OptState],
+            batch: Batch,
+        ) -> tuple[tuple[PyTree, optax.OptState], tuple[Output, FrozenDict[str, Array]]]:
+            model_arr, opt_state = carry
+            model_arr, opt_state, output, metrics = self.update(
+                model_arr,
+                model_static,
+                optimizer,
+                opt_state,
+                batch,
+                state,
+            )
+            return (model_arr, opt_state), (output, FrozenDict(metrics))
+
+        (model_arr, opt_state), (output, metrics) = xax_scan(
+            update_fn,
+            (model_arr, opt_state),
+            batches,
+            jit_level=3,
+        )
+
+        # Only get the final output and metrics.
+        output = jax.tree.map(lambda x: x[-1], output)
+        metrics = jax.tree.map(lambda x: x[-1], metrics)
+
+        return model_arr, opt_state, output, metrics
 
     @xax_jit(static_argnames=["self", "model_static"], jit_level=3)
     def val_step(
@@ -775,40 +767,36 @@ class TrainMixin(
                     output, metrics = self.val_step(model_arr, model_static, valid_batch, state)
                     self.log_step(eqx.combine(model_arr, model_static), valid_batch, output, metrics, state)
 
-                    state = state.replace(
-                        num_steps=state.num_steps + 1,
-                        num_samples=state.num_samples + (self.get_size_of_batch(valid_batch) or 0),
-                    )
-
                 state = state.replace(
+                    num_steps=state.num_steps + 1,
+                    num_samples=state.num_samples + (self.get_size_of_batch(valid_batch) or 0),
                     elapsed_time_s=state.elapsed_time_s + timer.elapsed_time,
                 )
 
             with ContextTimer() as timer:
                 state = self.on_step_start(state)
                 state = state.replace(phase="train")
-                train_batch = next(train_pf)
+                train_batches = list(itertools.islice(train_pf, self.config.updates_per_step))
                 model_arr, opt_state, output, metrics = self.train_step(
                     model_arr=model_arr,
                     model_static=model_static,
                     optimizer=optimizer,
                     opt_state=opt_state,
-                    batch=train_batch,
+                    batches=jax.tree.map(lambda *xs: jnp.stack(xs, axis=0), *train_batches),
                     state=state,
                 )
-                self.log_step(eqx.combine(model_arr, model_static), train_batch, output, metrics, state)
-
-                state = state.replace(
-                    num_steps=state.num_steps + 1,
-                    num_samples=state.num_samples + (self.get_size_of_batch(train_batch) or 0),
-                )
-
+                self.log_step(eqx.combine(model_arr, model_static), train_batches[-1], output, metrics, state)
                 state = self.on_step_end(state)
 
             state = state.replace(
+                num_steps=state.num_steps + 1,
+                num_samples=state.num_samples + (self.get_size_of_batch(train_batches[-1]) or 0),
                 elapsed_time_s=state.elapsed_time_s + timer.elapsed_time,
             )
 
+            if state.num_steps <= 3:
+                logger.log(LOG_PING, "Step %d took %.2f second", state.num_steps, timer.elapsed_time)
+
             if self.should_checkpoint(state):
                 model = eqx.combine(model_arr, model_static)
                 self.save_checkpoint(models=[model], optimizers=[optimizer], opt_states=[opt_state], state=state)
@@ -827,7 +815,7 @@ class TrainMixin(
             pass
 
         train_ds = self.get_dataset("train")
-        train_dl = self.get_dataloader(train_ds, "train")
+        train_dl = self.get_dataloader(train_ds, "train", prefetch_factor=self.config.updates_per_step + 1)
         train_pf = self.get_prefetcher(train_dl)
 
         try:

{xax-0.3.7.dist-info → xax-0.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xax
-Version: 0.3.7
+Version: 0.3.9
 Summary: A library for fast Jax experimentation
 Home-page: https://github.com/kscalelabs/xax
 Author: Benjamin Bolte

{xax-0.3.7.dist-info → xax-0.3.9.dist-info}/RECORD

@@ -1,4 +1,4 @@
-xax/__init__.py,sha256=YCDjLRwliJCyEmNFC56PNQXV9Vn9Fr13VJS_am4h3To,16336
+xax/__init__.py,sha256=PLNyZ5fOm0f2JduTMauNH2jqxN4g0GAZ9MSNzEsAQS4,16665
 xax/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xax/requirements-dev.txt,sha256=qkscNkFzWd1S5fump-AKH53rR65v2x5FmboFdy_kKvs,128
 xax/requirements.txt,sha256=6qY-84e-sTmlfJNrSjwONQKqzAn5h8G_oGIhnhmfSr4,302
@@ -9,6 +9,7 @@ xax/core/conf.py,sha256=d7Dp_GwKnaxtkztlSrJSM_LR0UYJX_FWTtceIWCBkxc,5138
 xax/core/state.py,sha256=_gtINsRc310Bu_HuIYsDoOKTZa6DgU2tz0IOKkdnY9Q,3813
 xax/nn/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xax/nn/attention.py,sha256=m6yEoRqf7-wLgrEltaR6CxF_Cody0MaNtAkuKk39qJI,31176
+xax/nn/distributions.py,sha256=096IDvoJ0ZA4SqcfgNSmrICsGcsKVcTAh0Vl6SwN3-o,6343
 xax/nn/embeddings.py,sha256=8tAuAPdkVj-U5IwtRZKHA0WYMFRbpCuwyAxcChdKhbE,11784
 xax/nn/functions.py,sha256=bA5kJYzMtFM8eUqBC086i355zJMAO7k_vPFNSDBI9-s,2814
 xax/nn/geom.py,sha256=c9K52vLm-V-15CRqMNx0OmqsWfb3PHQxXW4OSx9kCAk,10635
@@ -36,13 +37,13 @@ xax/task/mixins/artifacts.py,sha256=R-y3p7__zJHlHDqwDVAZysg2ZmebCJbqAx_xGT2Xpd0,
 xax/task/mixins/checkpointing.py,sha256=v50IZ7j58DWmEu-_6Zh_02R5KUVGhrMkg5n-MYM_J4c,11484
 xax/task/mixins/compile.py,sha256=PG5aF3W9v_xGiImHgUJ7gmwuQQoSQWufdpl2N_mlLX0,3922
 xax/task/mixins/cpu_stats.py,sha256=rO_9a82ZdsNec61ya4FpYE-rWqPhpijRSXsOfc6caFA,9595
-xax/task/mixins/data_loader.py,sha256=Tp7zqPdfH2_JuE6J6EP-fEtCQpq9MjKlGHYK7Zh-goU,6599
+xax/task/mixins/data_loader.py,sha256=BKfOVWXR70vbyHMFlnlUiQQHXHH5zTj5WtmsymNCFB4,6722
 xax/task/mixins/gpu_stats.py,sha256=USOyhXldxbsrl6eCtoFKTWUm_lfeG0cUCkQNUpXRdtA,8880
 xax/task/mixins/logger.py,sha256=6oXsJJyNUx6YT3q58FVXMZBUpMgjVkGre6BXFN20cVI,2808
 xax/task/mixins/process.py,sha256=hqDEsMp_SL6ee97iq26-G0g49OcWZZaX82JD4F22eJU,1781
 xax/task/mixins/runnable.py,sha256=pcLrYc_TycZUY9zZim05Skc2FWk3IZKFnu6p3UDMonM,1966
 xax/task/mixins/step_wrapper.py,sha256=-Yu5Nft2CRw1JvZt6J_94SM1vqX8fk08IDK95Pmd2ew,1648
-xax/task/mixins/train.py,sha256=bjBoigTCjbq9H4hcqIO32irHBc9rC2zkgXrnGNI2RtI,33266
+xax/task/mixins/train.py,sha256=_kDpifLi1arSuT0ssFhBV0axpvLlQG3a97pohya0Eqc,32908
 xax/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xax/utils/debugging.py,sha256=OtUdu-3tQsQtik0Q9UM-SNV46IbPjwrAfZcywzoB5d4,1940
 xax/utils/experiments.py,sha256=5k5hPYSaVjzoR_nm2Q3DAHMMYi3Bcp3N3PAQbwZq7Gg,29830
@@ -59,9 +60,9 @@ xax/utils/data/collate.py,sha256=Rd9vMomr_S_zCa_Hi4dO-8ntzAfVwndIUtuXFA3iNcc,706
 xax/utils/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 xax/utils/types/frozen_dict.py,sha256=ebtHENhyUzSjyJTlbMaLtcckQIJ7EtgJiok_40TJZpo,4689
 xax/utils/types/hashable_array.py,sha256=l5iIcFmkYzfGeaZmcSoeFkthFASqM8xJYK3AXhZQYwc,992
-xax-0.3.7.dist-info/licenses/LICENSE,sha256=HCN2bImAzUOXldAZZI7JZ9PYq6OwMlDAP_PpX1HnuN0,1071
-xax-0.3.7.dist-info/METADATA,sha256=8Zb0pvTJOjrCHK7giM2MbhlGCPREQewJK3GgRDQNWY0,1246
-xax-0.3.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xax-0.3.7.dist-info/entry_points.txt,sha256=uRC6rx5ce0bf-FblJaZSBMxxKFfMyoWTf8OWbBmLSe8,61
-xax-0.3.7.dist-info/top_level.txt,sha256=g4Au_r2XhvZ-lTybviH-Fh9g0zF4DAYHYxPue1-xbs8,4
-xax-0.3.7.dist-info/RECORD,,
+xax-0.3.9.dist-info/licenses/LICENSE,sha256=HCN2bImAzUOXldAZZI7JZ9PYq6OwMlDAP_PpX1HnuN0,1071
+xax-0.3.9.dist-info/METADATA,sha256=UKUqiAADutUzjtq4WpChJJzWDcfKBsrbWMmZu0LUqQk,1246
+xax-0.3.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xax-0.3.9.dist-info/entry_points.txt,sha256=uRC6rx5ce0bf-FblJaZSBMxxKFfMyoWTf8OWbBmLSe8,61
+xax-0.3.9.dist-info/top_level.txt,sha256=g4Au_r2XhvZ-lTybviH-Fh9g0zF4DAYHYxPue1-xbs8,4
+xax-0.3.9.dist-info/RECORD,,