xax 0.1.0__tar.gz → 0.1.1__tar.gz

{xax-0.1.0/xax.egg-info → xax-0.1.1}/PKG-INFO

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

{xax-0.1.0 → xax-0.1.1}/xax/__init__.py

@@ -12,7 +12,7 @@ and running the update script:
     python -m scripts.update_api --inplace
 """
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"
 
 # This list shouldn't be modified by hand; instead, run the update script.
 __all__ = [

{xax-0.1.0 → xax-0.1.1}/xax/task/logger.py

@@ -18,7 +18,7 @@ from abc import ABC, abstractmethod
 from collections import defaultdict
 from dataclasses import dataclass
 from types import TracebackType
-from typing import Callable, Iterator, Literal, Self, Sequence, TypeVar, get_args
+from typing import Callable, Iterator, Literal, Self, Sequence, TypeVar, cast, get_args
 
 import jax
 import jax.numpy as jnp
@@ -28,7 +28,7 @@ from PIL import Image, ImageDraw, ImageFont
 from PIL.Image import Image as PILImage
 
 from xax.core.state import Phase, State
-from xax.utils.experiments import IntervalTicker
+from xax.utils.experiments import ContextTimer, IntervalTicker
 from xax.utils.logging import LOG_ERROR_SUMMARY, LOG_PING, LOG_STATUS
 
 logger = logging.getLogger(__name__)
@@ -236,7 +236,7 @@ class LogHistogram:
     num: int
     sum: Number
     sum_squares: Number
-    bucket_limits: list[Number]
+    bucket_limits: list[float]
     bucket_counts: list[int]
 
 
@@ -564,14 +564,14 @@ class Logger:
         Args:
             state: The current step's state.
         """
-        should_log = [logger.should_log(state) for logger in self.loggers]
+        should_log = [lg.should_log(state) for lg in self.loggers]
         if not any(should_log):
             self.clear()
             return
         line = self.pack(state)
         self.clear()
-        for logger in (logger for logger, should_log in zip(self.loggers, should_log) if should_log):
-            logger.write(line)
+        for lg in (lg for lg, should_log in zip(self.loggers, should_log) if should_log):
+            lg.write(line)
 
     def write_error_summary(self, error_summary: str) -> None:
         for logger in self.loggers:
@@ -633,7 +633,10 @@ class Logger:
 
         @functools.lru_cache(maxsize=None)
         def scalar_future() -> Number:
-            return value() if callable(value) else value
+            with ContextTimer() as timer:
+                value_concrete = value() if callable(value) else value
+            logger.debug("Scalar Key: %s, Time: %s", key, timer.elapsed_time)
+            return value_concrete
 
         self.scalars[namespace][key] = scalar_future
 
@@ -657,7 +660,9 @@ class Logger:
 
         @functools.lru_cache(maxsize=None)
         def distribution_future() -> LogDistribution:
-            mean, std = value() if callable(value) else value
+            with ContextTimer() as timer:
+                mean, std = value() if callable(value) else value
+            logger.debug("Distribution Key: %s, Time: %s", key, timer.elapsed_time)
             return LogDistribution(mean=mean, std=std)
 
         self.distributions[namespace][key] = distribution_future
@@ -684,26 +689,84 @@ class Logger:
 
         @functools.lru_cache(maxsize=None)
         def histogram_future() -> LogHistogram:
-            values = value() if callable(value) else value
-            values = values.reshape(-1)  # Must be flat.
-
-            if isinstance(values, Array):
-                counts, limits = jnp.histogram(values, bins=bins)
-                counts, limits = as_numpy(counts), as_numpy(limits)
-            elif isinstance(values, np.ndarray):
-                counts, limits = np.histogram(values, bins=bins)
-            else:
-                raise ValueError(f"Unsupported histogram type: {type(values)}")
-
-            return LogHistogram(
-                min=float(values.min()),
-                max=float(values.max()),
-                num=int(values.size),
-                sum=float(values.sum()),
-                sum_squares=float(values.dot(values)),
-                bucket_limits=limits[1:].tolist(),
-                bucket_counts=counts.tolist(),
-            )
+            with ContextTimer() as timer:
+                values = value() if callable(value) else value
+                values = values.reshape(-1)  # Must be flat.
+
+                if isinstance(values, Array):
+                    counts, limits = jnp.histogram(values, bins=bins)
+                    counts, limits = as_numpy(counts), as_numpy(limits)
+                elif isinstance(values, np.ndarray):
+                    counts, limits = np.histogram(values, bins=bins)
+                else:
+                    raise ValueError(f"Unsupported histogram type: {type(values)}")
+
+                histogram_values = LogHistogram(
+                    min=float(values.min()),
+                    max=float(values.max()),
+                    num=int(values.size),
+                    sum=float(values.sum()),
+                    sum_squares=float(values.dot(values)),
+                    bucket_limits=cast(list[float], limits[1:].tolist()),
+                    bucket_counts=cast(list[int], counts.tolist()),
+                )
+
+            logger.debug("Histogram Key: %s, Time: %s", key, timer.elapsed_time)
+            return histogram_values
+
+        self.histograms[namespace][key] = histogram_future
+
+    def log_histogram_raw(
+        self,
+        key: str,
+        counts: Array | np.ndarray,
+        limits: Array | np.ndarray,
+        minv: Number | None = None,
+        maxv: Number | None = None,
+        sumv: Number | None = None,
+        sum_squaresv: Number | None = None,
+        *,
+        namespace: str | None = None,
+    ) -> None:
+        """Logs a histogram from raw counts and limits.
+
+        Args:
+            key: The key being logged
+            counts: The counts of the histogram
+            limits: The limits of the histogram
+            minv: The minimum value of the histogram
+            maxv: The maximum value of the histogram
+            sumv: The sum of the histogram
+            sum_squaresv: The sum of the squares of the histogram
+            namespace: An optional logging namespace
+        """
+        if not self.active:
+            raise RuntimeError("The logger is not active")
+        namespace = self.resolve_namespace(namespace)
+
+        @functools.lru_cache(maxsize=None)
+        def histogram_future() -> LogHistogram:
+            with ContextTimer() as timer:
+                counts_np = (as_numpy(counts) if isinstance(counts, Array) else counts).astype(int)
+                limits_np = (as_numpy(limits) if isinstance(limits, Array) else limits).astype(float)
+
+                minv_ = counts_np.min() if minv is None else minv
+                maxv_ = counts_np.max() if maxv is None else maxv
+                sumv_ = counts_np.sum() if sumv is None else sumv
+                sum_squaresv_ = counts_np.dot(counts_np) if sum_squaresv is None else sum_squaresv
+
+                histogram_values = LogHistogram(
+                    min=float(minv_),
+                    max=float(maxv_),
+                    num=int(counts_np.size),
+                    sum=float(sumv_),
+                    sum_squares=float(sum_squaresv_),
+                    bucket_limits=cast(list[float], limits_np.tolist()),
+                    bucket_counts=cast(list[int], counts_np.tolist()),
+                )
+
+            logger.debug("Raw Histogram Key: %s, Time: %s", key, timer.elapsed_time)
+            return histogram_values
 
         self.histograms[namespace][key] = histogram_future
 
@@ -748,7 +811,10 @@ class Logger:
 
         @functools.lru_cache(maxsize=None)
         def image_future() -> LogImage:
-            return get_image(value() if callable(value) else value, target_resolution)
+            with ContextTimer() as timer:
+                image = get_image(value() if callable(value) else value, target_resolution)
+            logger.debug("Image Key: %s, Time: %s", key, timer.elapsed_time)
+            return image
 
         self.images[namespace][key] = image_future
 
@@ -784,15 +850,20 @@ class Logger:
 
         @functools.lru_cache(maxsize=None)
         def image_future() -> LogImage:
-            image, label = value() if callable(value) else value
-            image = get_image(image, target_resolution)
-            return image_with_text(
-                image.image,
-                standardize_text(label, max_line_length),
-                max_num_lines=max_num_lines,
-                line_spacing=line_spacing,
-                centered=centered,
-            )
+            with ContextTimer() as timer:
+                image, label = value() if callable(value) else value
+                image = get_image(image, target_resolution)
+
+                image_value = image_with_text(
+                    image.image,
+                    standardize_text(label, max_line_length),
+                    max_num_lines=max_num_lines,
+                    line_spacing=line_spacing,
+                    centered=centered,
+                )
+
+            logger.debug("Labeled Image Key: %s, Time: %s", key, timer.elapsed_time)
+            return image_value
 
         self.images[namespace][key] = image_future
 
@@ -831,15 +902,18 @@ class Logger:
 
         @functools.lru_cache(maxsize=None)
         def images_future() -> LogImage:
-            images = value() if callable(value) else value
-            if max_images is not None:
-                images = images[:max_images]
-            if isinstance(images, Array):
-                images = as_numpy(images)
-            if isinstance(images, Sequence):
-                images = list(images)
-            images = [get_image(image, target_resolution) for image in images]
-            tiled = tile_images([img.image for img in images], sep)
+            with ContextTimer() as timer:
+                images = value() if callable(value) else value
+                if max_images is not None:
+                    images = images[:max_images]
+                if isinstance(images, Array):
+                    images = as_numpy(images)
+                if isinstance(images, Sequence):
+                    images = list(images)
+                images = [get_image(image, target_resolution) for image in images]
+                tiled = tile_images([img.image for img in images], sep)
+
+            logger.debug("Images Key: %s, Time: %s", key, timer.elapsed_time)
             return LogImage(image=tiled)
 
         self.images[namespace][key] = images_future
@@ -886,22 +960,25 @@ class Logger:
 
         @functools.lru_cache(maxsize=None)
         def images_future() -> LogImage:
-            images, labels = value() if callable(value) else value
-            if max_images is not None:
-                images = images[:max_images]
-                labels = labels[:max_images]
-            images = [get_image(image, target_resolution) for image in images]
-            labeled = [
-                image_with_text(
-                    img.image,
-                    standardize_text(label, max_line_length),
-                    max_num_lines=max_num_lines,
-                    line_spacing=line_spacing,
-                    centered=centered,
-                )
-                for img, label in zip(images, labels)
-            ]
-            tiled = tile_images([img.image for img in labeled], sep)
+            with ContextTimer() as timer:
+                images, labels = value() if callable(value) else value
+                if max_images is not None:
+                    images = images[:max_images]
+                    labels = labels[:max_images]
+                images = [get_image(image, target_resolution) for image in images]
+                labeled = [
+                    image_with_text(
+                        img.image,
+                        standardize_text(label, max_line_length),
+                        max_num_lines=max_num_lines,
+                        line_spacing=line_spacing,
+                        centered=centered,
+                    )
+                    for img, label in zip(images, labels)
+                ]
+                tiled = tile_images([img.image for img in labeled], sep)
+
+            logger.debug("Labeled Images Key: %s, Time: %s", key, timer.elapsed_time)
             return LogImage(image=tiled)
 
         self.images[namespace][key] = images_future
@@ -934,7 +1011,11 @@ class Logger:
 
         @functools.lru_cache(maxsize=None)
         def video_future() -> LogVideo:
-            return get_video(value() if callable(value) else value, fps=fps)
+            with ContextTimer() as timer:
+                video = get_video(value() if callable(value) else value, fps=fps)
+
+            logger.debug("Video Key: %s, Time: %s", key, timer.elapsed_time)
+            return video
 
         self.videos[namespace][key] = video_future
 

{xax-0.1.0 → xax-0.1.1}/xax/task/mixins/train.py

@@ -156,7 +156,6 @@ class TrainConfig(
     valid_first_n_steps: int = field(0, help="Treat the first N steps as validation steps")
     valid_every_n_seconds: float | None = field(60.0 * 10.0, help="Run validation every N seconds")
     valid_first_n_seconds: float | None = field(60.0, help="Run first validation after N seconds")
-    batch_dim: int = field(0, help="The batch dimension, for splitting batches into chunks")
     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))}]")
     random_seed: int = field(1337, help="Random seed for the task")

{xax-0.1.0 → xax-0.1.1}/xax/utils/logging.py

@@ -140,7 +140,13 @@ class ColoredFormatter(logging.Formatter):
         return logging.Formatter.format(self, record)
 
 
-def configure_logging(prefix: str | None = None, *, rank: int | None = None, world_size: int | None = None) -> None:
+def configure_logging(
+    prefix: str | None = None,
+    *,
+    rank: int | None = None,
+    world_size: int | None = None,
+    debug: bool | None = None,
+) -> None:
     """Instantiates logging.
 
     This captures logs and reroutes them to the Toasts module, which is
@@ -151,6 +157,7 @@ def configure_logging(prefix: str | None = None, *, rank: int | None = None, wor
         prefix: An optional prefix to add to the logger
         rank: The current rank, or None if not using multiprocessing
         world_size: The total world size, or None if not using multiprocessing
+        debug: Whether to enable debug logging
     """
     if rank is not None or world_size is not None:
         assert rank is not None and world_size is not None
@@ -168,7 +175,10 @@ def configure_logging(prefix: str | None = None, *, rank: int | None = None, wor
     stream_handler.addFilter(filter)
     root_logger.addHandler(stream_handler)
 
-    root_logger.setLevel(logging._nameToLevel[config.log_level])
+    if debug is None:
+        root_logger.setLevel(logging._nameToLevel[config.log_level])
+    else:
+        root_logger.setLevel(logging.DEBUG if debug else logging.INFO)
 
     # Avoid junk logs from other libraries.
     if config.hide_third_party_logs:

{xax-0.1.0 → xax-0.1.1/xax.egg-info}/PKG-INFO

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