rslearn 0.0.12__py3-none-any.whl → 0.0.13__py3-none-any.whl

rslearn/config/dataset.py

@@ -125,7 +125,8 @@ class BandSetConfig:
         self,
         config_dict: dict[str, Any],
         dtype: DType,
-        bands: list[str],
+        bands: list[str] | None = None,
+        num_bands: int | None = None,
         format: dict[str, Any] | None = None,
         zoom_offset: int = 0,
         remap: dict[str, Any] | None = None,
@@ -137,7 +138,10 @@ class BandSetConfig:
         Args:
             config_dict: the config dict used to configure this BandSetConfig
             dtype: the pixel value type to store tiles in
-            bands: list of band names in this BandSetConfig
+            bands: list of band names in this BandSetConfig. One of bands or num_bands
+                must be set.
+            num_bands: the number of bands in this band set. The bands will be named
+                B00, B01, B02, etc.
             format: the format to store tiles in, defaults to geotiff
             zoom_offset: store images at a resolution higher or lower than the window
                 resolution. This enables keeping source data at its native resolution,
@@ -155,6 +159,14 @@ class BandSetConfig:
                 materialization when creating mosaics, to determine which parts of the
                 source images should be copied.
         """
+        if (bands is None and num_bands is None) or (
+            bands is not None and num_bands is not None
+        ):
+            raise ValueError("exactly one of bands and num_bands must be set")
+        if bands is None:
+            assert num_bands is not None
+            bands = [f"B{idx}" for idx in range(num_bands)]
+
         if class_names is not None and len(bands) != len(class_names):
             raise ValueError(
                 f"the number of class lists ({len(class_names)}) does not match the number of bands ({len(bands)})"
@@ -187,9 +199,16 @@ class BandSetConfig:
         kwargs = dict(
             config_dict=config,
             dtype=DType(config["dtype"]),
-            bands=config["bands"],
         )
-        for k in ["format", "zoom_offset", "remap", "class_names", "nodata_vals"]:
+        for k in [
+            "bands",
+            "num_bands",
+            "format",
+            "zoom_offset",
+            "remap",
+            "class_names",
+            "nodata_vals",
+        ]:
             if k in config:
                 kwargs[k] = config[k]
         return BandSetConfig(**kwargs)  # type: ignore

rslearn/data_sources/planetary_computer.py

@@ -827,3 +827,55 @@ class Sentinel1(PlanetaryComputer):
                 kwargs[k] = d[k]
 
         return Sentinel1(**kwargs)
+
+
+class Naip(PlanetaryComputer):
+    """A data source for NAIP data on Microsoft Planetary Computer.
+
+    See https://planetarycomputer.microsoft.com/dataset/naip.
+    """
+
+    COLLECTION_NAME = "naip"
+    ASSET_BANDS = {"image": ["R", "G", "B", "NIR"]}
+
+    def __init__(
+        self,
+        **kwargs: Any,
+    ):
+        """Initialize a new Naip instance.
+
+        Args:
+            band_names: list of bands to try to ingest.
+            kwargs: additional arguments to pass to PlanetaryComputer.
+        """
+        super().__init__(
+            collection_name=self.COLLECTION_NAME,
+            asset_bands=self.ASSET_BANDS,
+            **kwargs,
+        )
+
+    @staticmethod
+    def from_config(config: RasterLayerConfig, ds_path: UPath) -> "Naip":
+        """Creates a new Naip instance from a configuration dictionary."""
+        if config.data_source is None:
+            raise ValueError("config.data_source is required")
+        d = config.data_source.config_dict
+        kwargs = {}
+
+        if "timeout_seconds" in d:
+            kwargs["timeout"] = timedelta(seconds=d["timeout_seconds"])
+
+        if "cache_dir" in d:
+            kwargs["cache_dir"] = join_upath(ds_path, d["cache_dir"])
+
+        simple_optionals = [
+            "query",
+            "sort_by",
+            "sort_ascending",
+            "max_items_per_client",
+        ]
+        for k in simple_optionals:
+            if k in d:
+                kwargs[k] = d[k]
+
+        return Naip(**kwargs)

rslearn/dataset/handler_summaries.py

@@ -20,6 +20,7 @@ class LayerPrepareSummary:
     # Counts
     windows_prepared: int
     windows_skipped: int
+    windows_rejected: int
     get_items_attempts: int
 
 

rslearn/dataset/manage.py

@@ -118,6 +118,7 @@ def prepare_dataset_windows(
                     duration_seconds=time.monotonic() - layer_start_time,
                     windows_prepared=0,
                     windows_skipped=len(windows),
+                    windows_rejected=0,
                     get_items_attempts=0,
                 )
             )
@@ -141,6 +142,7 @@ def prepare_dataset_windows(
                     duration_seconds=time.monotonic() - layer_start_time,
                     windows_prepared=0,
                     windows_skipped=len(windows),
+                    windows_rejected=0,
                     get_items_attempts=0,
                 )
             )
@@ -181,6 +183,9 @@ def prepare_dataset_windows(
             attempts_counter=attempts_counter,
         )
 
+        windows_prepared = 0
+        windows_rejected = 0
+        min_matches = data_source_cfg.query_config.min_matches
         for window, result in zip(needed_windows, results):
             layer_datas = window.load_layer_datas()
             layer_datas[layer_name] = WindowLayerData(
@@ -191,13 +196,22 @@ def prepare_dataset_windows(
             )
             window.save_layer_datas(layer_datas)
 
+            # If result is empty and min_matches > 0, window was rejected due to min_matches
+            if len(result) == 0 and min_matches > 0:
+                windows_rejected += 1
+            else:
+                windows_prepared += 1
+
+        windows_skipped = len(windows) - len(needed_windows)
+
         layer_summaries.append(
             LayerPrepareSummary(
                 layer_name=layer_name,
                 data_source_name=data_source_cfg.name,
                 duration_seconds=time.monotonic() - layer_start_time,
-                windows_prepared=len(needed_windows),  # we assume all have succeeded
-                windows_skipped=len(windows) - len(needed_windows),
+                windows_prepared=windows_prepared,
+                windows_skipped=windows_skipped,
+                windows_rejected=windows_rejected,
                 get_items_attempts=attempts_counter.value,
             )
         )

rslearn/models/olmoearth_pretrain/model.py

@@ -40,6 +40,7 @@ EMBEDDING_SIZES = {
     ModelID.OLMOEARTH_V1_NANO: 128,
     ModelID.OLMOEARTH_V1_TINY: 192,
     ModelID.OLMOEARTH_V1_BASE: 768,
+    ModelID.OLMOEARTH_V1_LARGE: 1024,
 }
 
 

rslearn/train/prediction_writer.py

@@ -22,7 +22,11 @@ from rslearn.log_utils import get_logger
 from rslearn.utils.array import copy_spatial_array
 from rslearn.utils.feature import Feature
 from rslearn.utils.geometry import PixelBounds
-from rslearn.utils.raster_format import RasterFormat, load_raster_format
+from rslearn.utils.raster_format import (
+    RasterFormat,
+    adjust_projection_and_bounds_for_array,
+    load_raster_format,
+)
 from rslearn.utils.vector_format import VectorFormat, load_vector_format
 
 from .lightning_module import RslearnLightningModule
@@ -68,15 +72,18 @@ class VectorMerger(PatchPredictionMerger):
 class RasterMerger(PatchPredictionMerger):
     """Merger for raster data that copies the rasters to the output."""
 
-    def __init__(self, padding: int | None = None):
+    def __init__(self, padding: int | None = None, downsample_factor: int = 1):
         """Create a new RasterMerger.
 
         Args:
             padding: the padding around the individual patch outputs to remove. This is
                 typically used when leveraging overlapping patches. Portions of outputs
                 at the border of the window will still be retained.
+            downsample_factor: the factor by which the rasters output by the task are
+                lower in resolution relative to the window resolution.
         """
         self.padding = padding
+        self.downsample_factor = downsample_factor
 
     def merge(
         self, window: Window, outputs: Sequence[PendingPatchOutput]
@@ -87,8 +94,8 @@ class RasterMerger(PatchPredictionMerger):
         merged_image = np.zeros(
             (
                 num_channels,
-                window.bounds[3] - window.bounds[1],
-                window.bounds[2] - window.bounds[0],
+                (window.bounds[3] - window.bounds[1]) // self.downsample_factor,
+                (window.bounds[2] - window.bounds[0]) // self.downsample_factor,
             ),
             dtype=dtype,
         )
@@ -104,7 +111,10 @@ class RasterMerger(PatchPredictionMerger):
             # If the output is not on the left or top boundary, then we should apply
             # the padding (if set).
             src = output.output
-            src_offset = (output.bounds[0], output.bounds[1])
+            src_offset = (
+                output.bounds[0] // self.downsample_factor,
+                output.bounds[1] // self.downsample_factor,
+            )
             if self.padding is not None and output.bounds[0] != window.bounds[0]:
                 src = src[:, :, self.padding :]
                 src_offset = (src_offset[0] + self.padding, src_offset[1])
@@ -116,7 +126,10 @@ class RasterMerger(PatchPredictionMerger):
                 src=src,
                 dst=merged_image,
                 src_offset=src_offset,
-                dst_offset=(window.bounds[0], window.bounds[1]),
+                dst_offset=(
+                    window.bounds[0] // self.downsample_factor,
+                    window.bounds[1] // self.downsample_factor,
+                ),
             )
 
         return merged_image
@@ -330,9 +343,13 @@ class RslearnWriter(BasePredictionWriter):
                 self.output_layer, self.layer_config.band_sets[0].bands
             )
             assert isinstance(self.format, RasterFormat)
-            self.format.encode_raster(
-                raster_dir, window.projection, window.bounds, merged_output
+
+            # In case the merged_output is at a different resolution than the window,
+            # get adjusted projection and bounds for writing it.
+            projection, bounds = adjust_projection_and_bounds_for_array(
+                window.projection, window.bounds, merged_output
             )
+            self.format.encode_raster(raster_dir, projection, bounds, merged_output)
 
         elif self.layer_config.layer_type == LayerType.VECTOR:
             layer_dir = window.get_layer_dir(self.output_layer)

rslearn/train/tasks/embedding.py

@@ -0,0 +1,116 @@
+"""Embedding task."""
+
+from typing import Any
+
+import numpy.typing as npt
+import torch
+from torchmetrics import MetricCollection
+
+from rslearn.utils import Feature
+
+from .task import Task
+
+
+class EmbeddingTask(Task):
+    """A dummy task for computing embeddings.
+
+    This task does not compute any targets or loss. Instead, it is just set up for
+    inference, to save embeddings from the configured model.
+    """
+
+    def process_inputs(
+        self,
+        raw_inputs: dict[str, torch.Tensor],
+        metadata: dict[str, Any],
+        load_targets: bool = True,
+    ) -> tuple[dict[str, Any], dict[str, Any]]:
+        """Processes the data into targets.
+
+        Args:
+            raw_inputs: raster or vector data to process
+            metadata: metadata about the patch being read
+            load_targets: whether to load the targets or only inputs
+
+        Returns:
+            tuple (input_dict, target_dict) containing the processed inputs and targets
+                that are compatible with both metrics and loss functions
+        """
+        return {}, {}
+
+    def process_output(
+        self, raw_output: Any, metadata: dict[str, Any]
+    ) -> npt.NDArray[Any] | list[Feature]:
+        """Processes an output into raster or vector data.
+
+        Args:
+            raw_output: the output from prediction head.
+            metadata: metadata about the patch being read
+
+        Returns:
+            either raster or vector data.
+        """
+        # Just convert the raw output to numpy array that can be saved to GeoTIFF.
+        return raw_output.cpu().numpy()
+
+    def visualize(
+        self,
+        input_dict: dict[str, Any],
+        target_dict: dict[str, Any] | None,
+        output: Any,
+    ) -> dict[str, npt.NDArray[Any]]:
+        """Visualize the outputs and targets.
+
+        Args:
+            input_dict: the input dict from process_inputs
+            target_dict: the target dict from process_inputs
+            output: the prediction
+
+        Returns:
+            a dictionary mapping image name to visualization image
+        """
+        # EmbeddingTask is only set up to support `model predict`.
+        raise NotImplementedError
+
+    def get_metrics(self) -> MetricCollection:
+        """Get the metrics for this task."""
+        return MetricCollection({})
+
+
+class EmbeddingHead(torch.nn.Module):
+    """Head for embedding task.
+
+    This picks one feature map from the input list of feature maps to output. It also
+    returns a dummy loss.
+    """
+
+    def __init__(self, feature_map_index: int | None = 0):
+        """Create a new EmbeddingHead.
+
+        Args:
+            feature_map_index: the index of the feature map to choose from the input
+                list of multi-scale feature maps (default 0). If the input is already
+                a single feature map, then set to None.
+        """
+        super().__init__()
+        self.feature_map_index = feature_map_index
+
+    def forward(
+        self,
+        features: torch.Tensor,
+        inputs: list[dict[str, Any]],
+        targets: list[dict[str, Any]] | None = None,
+    ) -> tuple[torch.Tensor, dict[str, Any]]:
+        """Select the desired feature map and return it along with a dummy loss.
+
+        Args:
+            features: list of BCHW feature maps (or one feature map, if feature_map_index is None).
+            inputs: original inputs (ignored).
+            targets: should contain classes key that stores the per-pixel class labels.
+
+        Returns:
+            tuple of outputs and loss dict
+        """
+        if self.feature_map_index is not None:
+            features = features[self.feature_map_index]
+
+        return features, {"loss": 0}

rslearn/utils/raster_format.py

@@ -123,6 +123,44 @@ def get_transform_from_projection_and_bounds(
     )
 
 
+def adjust_projection_and_bounds_for_array(
+    projection: Projection, bounds: PixelBounds, array: npt.NDArray
+) -> tuple[Projection, PixelBounds]:
+    """Adjust the projection and bounds to correspond to the resolution of the array.
+
+    The returned projection and bounds cover the same spatial extent as the inputs, but
+    are updated so that the width and height match that of the array.
+
+    Args:
+        projection: the original projection.
+        bounds: the original bounds.
+        array: the CHW array for which to compute an updated projection and bounds. The
+            returned bounds will have the same width and height as this array.
+
+    Returns:
+        a tuple of adjusted (projection, bounds)
+    """
+    if array.shape[2] == (bounds[2] - bounds[0]) and array.shape[1] == (
+        bounds[3] - bounds[1]
+    ):
+        return (projection, bounds)
+
+    x_factor = array.shape[2] / (bounds[2] - bounds[0])
+    y_factor = array.shape[1] / (bounds[3] - bounds[1])
+    adjusted_projection = Projection(
+        projection.crs,
+        projection.x_resolution / x_factor,
+        projection.y_resolution / y_factor,
+    )
+    adjusted_bounds = (
+        round(bounds[0] * x_factor),
+        round(bounds[1] * y_factor),
+        round(bounds[0] * x_factor) + array.shape[2],
+        round(bounds[1] * y_factor) + array.shape[1],
+    )
+    return (adjusted_projection, adjusted_bounds)
+
+
 class RasterFormat:
     """An abstract class for writing raster data.
 

{rslearn-0.0.12.dist-info → rslearn-0.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rslearn
-Version: 0.0.12
+Version: 0.0.13
 Summary: A library for developing remote sensing datasets and models
 Author: OlmoEarth Team
 License:                                  Apache License
@@ -214,7 +214,7 @@ License-File: LICENSE
 License-File: NOTICE
 Requires-Dist: boto3>=1.39
 Requires-Dist: fiona>=1.10
-Requires-Dist: fsspec>=2025.9.0
+Requires-Dist: fsspec>=2025.10.0
 Requires-Dist: jsonargparse>=4.35.0
 Requires-Dist: lightning>=2.5.1.post0
 Requires-Dist: Pillow>=11.3

{rslearn-0.0.12.dist-info → rslearn-0.0.13.dist-info}/RECORD

@@ -6,7 +6,7 @@ rslearn/main.py,sha256=fLYmm2ZsUTCaJBKZvxu3pc4fB2thaf-p2Qv0AifDlXM,31292
 rslearn/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 rslearn/template_params.py,sha256=Vop0Ha-S44ctCa9lvSZRjrMETznJZlR5y_gJrVIwrPg,791
 rslearn/config/__init__.py,sha256=Bhf2VVncdMYRC8Wfb4GsJJ13OAJYNCO_ODLSNTmBOHM,638
-rslearn/config/dataset.py,sha256=cR6Jd9ppzHgKHCteUsNapCcsJk4k5X90E71EHfbW7m0,21046
+rslearn/config/dataset.py,sha256=VpXUGKCr45kzE-W27rgF4tPQuyICfwQkJTxb2z9aXQM,21685
 rslearn/data_sources/__init__.py,sha256=8_7Pi3agKsatNoxXw74-U5G-QAP-rbdfcH8EkZfJbH4,1449
 rslearn/data_sources/aws_landsat.py,sha256=GA9H04KagBDm-N37jFdh_aHCX2ZneVdnqT1SNOyAwTs,20829
 rslearn/data_sources/aws_open_data.py,sha256=nU_D5cqc-wibxq4uyUNb0z-XD0Puf1gZ8v5FMiMAN5w,30258
@@ -24,7 +24,7 @@ rslearn/data_sources/local_files.py,sha256=d08m6IzrUN_80VfvgpHahMJrv-n6_CI6EIocp
 rslearn/data_sources/openstreetmap.py,sha256=qUSMFiIA_laJkO3meBXf9TmSI7OBD-o3i4JxqllUv3Q,19232
 rslearn/data_sources/planet.py,sha256=F2JoLaQ5Cb3k1cTm0hwSWTL2TPfbaAUMXZ8q4Dy7UlA,10109
 rslearn/data_sources/planet_basemap.py,sha256=wuWM9dHSJMdINfyWb78Zk9i-KvJHTrf9J0Q2gyEyiiA,10450
-rslearn/data_sources/planetary_computer.py,sha256=uHNYxvnMkmo8zbqIiDRdnkz8LQ7TSs6K39Y1AXjboDI,30392
+rslearn/data_sources/planetary_computer.py,sha256=Vi-aBHQe-BA8NjRyPMgurMAdo3sK6PJteCK5MwXygJo,31869
 rslearn/data_sources/raster_source.py,sha256=b8wo55GhVLxXwx1WYLzeRAlzD_ZkE_P9tnvUOdnsfQE,689
 rslearn/data_sources/usda_cdl.py,sha256=2_V11AhPRgLEGd4U5Pmx3UvE2HWBPbsFXhUIQVRVFeE,7138
 rslearn/data_sources/usgs_landsat.py,sha256=31GmOUfmxwTE6MTiVI4psb-ciVmunuA8cfvqDuvTHPE,19312
@@ -37,9 +37,9 @@ rslearn/data_sources/xyz_tiles.py,sha256=SJV8TB6WUP6DTPr2d3LXRKVjFxda7bdR9IM84Vv
 rslearn/dataset/__init__.py,sha256=bHtBlEEBCekO-gaJqiww0-VjvZTE5ahx0llleo8bfP8,289
 rslearn/dataset/add_windows.py,sha256=pwCEvwLE1jQCoqQxw6CJ-sP46ayWppFa2hGYIB6VVkc,8494
 rslearn/dataset/dataset.py,sha256=bjf9nI55j-MF0bIQWSNPjNbpfqnLK4jy-96TAcwO0MM,5214
-rslearn/dataset/handler_summaries.py,sha256=wGnbBpjLWTxVn3UT7j7nPoHlYsaWb9_MVJ5DhU0qWXY,2581
+rslearn/dataset/handler_summaries.py,sha256=wI99RDk5erCWkzl1A7Uc4chatQ9KWIr4F_0Hxr9Co6s,2607
 rslearn/dataset/index.py,sha256=Wni5m6h4gisRB54fPLnCfUrRTEsJ5EvwS0fs9sYc2wg,6025
-rslearn/dataset/manage.py,sha256=mkdBHo1RFGxMx8f9zBT_VmRO_6y8Qb2KfWPPziKWYkg,18062
+rslearn/dataset/manage.py,sha256=owelBiBqvoIQYLhFMDK4ULzcoGBNE27JV8kl68jf3wg,18563
 rslearn/dataset/materialize.py,sha256=-z47svc_JqGhzkp8kq5Hd9fykWNqFEUCQezo887TWBw,22056
 rslearn/dataset/remap.py,sha256=6MaImsY02GNACpvRM81RvWmjZWRfAHxo_R3Ox6XLF6A,2723
 rslearn/dataset/window.py,sha256=I5RqZ12jlIXhohw4qews1x_I4tSDpml709DZRtLiN24,12546
@@ -86,7 +86,7 @@ rslearn/models/galileo/__init__.py,sha256=QQa0C29nuPRva0KtGiMHQ2ZB02n9SSwj_wqTKP
 rslearn/models/galileo/galileo.py,sha256=jUHA64YvVC3Fz5fevc_9dFJfZaINODRDrhSGLIiOZcw,21115
 rslearn/models/galileo/single_file_galileo.py,sha256=l5tlmmdr2eieHNH-M7rVIvcptkv0Fuk3vKXFW691ezA,56143
 rslearn/models/olmoearth_pretrain/__init__.py,sha256=AjRvbjBdadCdPh-EdvySH76sVAQ8NGQaJt11Tsn1D5I,36
-rslearn/models/olmoearth_pretrain/model.py,sha256=I_RWFbwzO5yCWpEcEQP8PeiD8M1QpeMtVrjl15evIHU,10632
+rslearn/models/olmoearth_pretrain/model.py,sha256=ZJgoyy7vwB0PUMJtHF-sdJ-uSBqnUXMDBco0Dx4cAes,10670
 rslearn/models/olmoearth_pretrain/norm.py,sha256=rHjFyWkpNLYMx9Ow7TsU-jGm9Sjx7FVf0p4R__ohx2c,3266
 rslearn/models/panopticon_data/sensors/drone.yaml,sha256=xqWS-_QMtJyRoWXJm-igoSur9hAmCFdqkPin8DT5qpw,431
 rslearn/models/panopticon_data/sensors/enmap.yaml,sha256=b2j6bSgYR2yKR9DRm3SPIzSVYlHf51ny_p-1B4B9sB4,13431
@@ -111,7 +111,7 @@ rslearn/train/data_module.py,sha256=K-nQgnOZn-KGq_G2pVOQFtWRrlWih0212i_bkXZ2bEE,
 rslearn/train/dataset.py,sha256=YiskNlYYcKqZxyw0Xzop1RGLbjMc-oK_rmhrSMVbTQg,51857
 rslearn/train/lightning_module.py,sha256=ZLBiId3secUlVs2yzkN-mwVv4rMdh5TkdZYl4vv_Cw0,14466
 rslearn/train/optimizer.py,sha256=EKSqkmERalDA0bF32Gey7n6z69KLyaUWKlRsGJfKBmE,927
-rslearn/train/prediction_writer.py,sha256=YNs92QqPrqbREZXoE-aPa_oKQW0C9LvZAY129vyvI08,13288
+rslearn/train/prediction_writer.py,sha256=mDvREwEB5k5_tNuBnYIvAGnxS3sYFWQYvV07V3UEe2k,14106
 rslearn/train/scheduler.py,sha256=wFbmycMHgL6nRYeYalDjb0G8YVo8VD3T3sABS61jJ7c,2318
 rslearn/train/callbacks/__init__.py,sha256=VNV0ArZyYMvl3dGK2wl6F046khYJ1dEBlJS6G_SYNm0,47
 rslearn/train/callbacks/adapters.py,sha256=yfv8nyCj3jmo2_dNkFrjukKxh0MHsf2xKqWwMF0QUtY,1869
@@ -121,6 +121,7 @@ rslearn/train/callbacks/peft.py,sha256=wEOKsS3RhsRaZTXn_Kz2wdsZdIiIaZPdCJWtdJBur
 rslearn/train/tasks/__init__.py,sha256=dag1u72x1-me6y0YcOubUo5MYZ0Tjf6-dOir9UeFNMs,75
 rslearn/train/tasks/classification.py,sha256=kahVdXPU6fDwDCdqlrjZGb9uA-PYG74DbQQ0kJUt-Eg,13186
 rslearn/train/tasks/detection.py,sha256=9j9webusrjGexvUmZ7gl3NTBS63Qq511VFlB2WbLi5Y,22302
+rslearn/train/tasks/embedding.py,sha256=DK3l1aQ3d5gQUT1h3cD6vcUaNKvSsH26RHx2Bbzutbg,3667
 rslearn/train/tasks/multi_task.py,sha256=dBWsnbvQ0CReNsbDHmZ_-sXjUE0H4S2OPcbJwMquG9g,6016
 rslearn/train/tasks/per_pixel_regression.py,sha256=W8dbLyIiPgFI3gA_aZQX0pSFRWLP2v6tthsFbKhcDVg,8783
 rslearn/train/tasks/regression.py,sha256=zZhrrZ1qxjrdLjKWC9McRivDXCcKiYfdLC-kaMeVkDc,11547
@@ -145,16 +146,16 @@ rslearn/utils/get_utm_ups_crs.py,sha256=kUrcyjCK7KWvuP1XR-nURPeRqYeRO-3L8QUJ1QTF
 rslearn/utils/grid_index.py,sha256=hRmrtgpqN1pLa-djnZtgSXqKJlbgGyttGnCEmPLD0zo,2347
 rslearn/utils/jsonargparse.py,sha256=JcTKQoZ6jgwag-kSeTIEVBO9AsRj0X1oEJBsoaCazH4,658
 rslearn/utils/mp.py,sha256=XYmVckI5TOQuCKc49NJyirDJyFgvb4AI-gGypG2j680,1399
-rslearn/utils/raster_format.py,sha256=dBTSa8l6Ms9Ndbx9Krgqm9z4RU7j2hwLBkw2w-KibU4,26009
+rslearn/utils/raster_format.py,sha256=RDzDPnWUJunqcj-F4oXKBl-rKFBUpRjvq7mMYhid3iU,27413
 rslearn/utils/rtree_index.py,sha256=j0Zwrq3pXuAJ-hKpiRFQ7VNtvO3fZYk-Em2uBPAqfx4,6460
 rslearn/utils/spatial_index.py,sha256=eomJAUgzmjir8j9HZnSgQoJHwN9H0wGTjmJkMkLLfsU,762
 rslearn/utils/sqlite_index.py,sha256=YGOJi66544e6JNtfSft6YIlHklFdSJO2duxQ4TJ2iu4,2920
 rslearn/utils/time.py,sha256=2ilSLG94_sxLP3y5RSV5L5CG8CoND_dbdzYEHVtN-I8,387
 rslearn/utils/vector_format.py,sha256=EIChYCL6GLOILS2TO2JBkca1TuaWsSubWv6iRS3P2ds,16139
-rslearn-0.0.12.dist-info/licenses/LICENSE,sha256=_99ZWPoLdlUbqZoSC5DF4ihiNwl5rTEmBaq2fACecdg,11352
-rslearn-0.0.12.dist-info/licenses/NOTICE,sha256=wLPr6rwV_jCg-xEknNGwhnkfRfuoOE9MZ-lru2yZyLI,5070
-rslearn-0.0.12.dist-info/METADATA,sha256=0jHeiz1QCT56zOws1CGGFVM9TotMOWIboQmGASdZAwY,36318
-rslearn-0.0.12.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-rslearn-0.0.12.dist-info/entry_points.txt,sha256=doTBQ57NT7nq-dgYGgTTw6mafcGWb_4PWYtYR4rGm50,46
-rslearn-0.0.12.dist-info/top_level.txt,sha256=XDKo90WBH8P9RQumHxo0giLJsoufT4r9odv-WE6Ahk4,8
-rslearn-0.0.12.dist-info/RECORD,,
+rslearn-0.0.13.dist-info/licenses/LICENSE,sha256=_99ZWPoLdlUbqZoSC5DF4ihiNwl5rTEmBaq2fACecdg,11352
+rslearn-0.0.13.dist-info/licenses/NOTICE,sha256=wLPr6rwV_jCg-xEknNGwhnkfRfuoOE9MZ-lru2yZyLI,5070
+rslearn-0.0.13.dist-info/METADATA,sha256=44oDmbvkIrjJ0unVNaYeO5OypD6RavmG7l5HUz9Re48,36319
+rslearn-0.0.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rslearn-0.0.13.dist-info/entry_points.txt,sha256=doTBQ57NT7nq-dgYGgTTw6mafcGWb_4PWYtYR4rGm50,46
+rslearn-0.0.13.dist-info/top_level.txt,sha256=XDKo90WBH8P9RQumHxo0giLJsoufT4r9odv-WE6Ahk4,8
+rslearn-0.0.13.dist-info/RECORD,,