geoai-py 0.4.0__py2.py3-none-any.whl → 0.4.2__py2.py3-none-any.whl

geoai/train.py

@@ -571,33 +571,51 @@ def train_MaskRCNN_model(
     output_dir,
     num_channels=3,
     pretrained=True,
+    pretrained_model_path=None,
     batch_size=4,
     num_epochs=10,
     learning_rate=0.005,
     seed=42,
     val_split=0.2,
     visualize=False,
+    resume_training=False,
 ):
-    """
-    Train and evaluate Mask R-CNN model for instance segmentation.
+    """Train and evaluate Mask R-CNN model for instance segmentation.
+
+    This function trains a Mask R-CNN model for instance segmentation using the
+    provided dataset. It supports loading a pretrained model to either initialize
+    the backbone or to continue training from a specific checkpoint.
 
     Args:
         images_dir (str): Directory containing image GeoTIFF files.
         labels_dir (str): Directory containing label GeoTIFF files.
         output_dir (str): Directory to save model checkpoints and results.
         num_channels (int, optional): Number of input channels. If None, auto-detected.
-        pretrained (bool): Whether to use pretrained backbone.
-        batch_size (int): Batch size for training.
-        num_epochs (int): Number of training epochs.
-        learning_rate (float): Initial learning rate.
-        seed (int): Random seed for reproducibility.
-        val_split (float): Fraction of data to use for validation (0-1).
+            Defaults to 3.
+        pretrained (bool): Whether to use pretrained backbone. This is ignored if
+            pretrained_model_path is provided. Defaults to True.
+        pretrained_model_path (str, optional): Path to a .pth file to load as a
+            pretrained model for continued training. Defaults to None.
+        batch_size (int): Batch size for training. Defaults to 4.
+        num_epochs (int): Number of training epochs. Defaults to 10.
+        learning_rate (float): Initial learning rate. Defaults to 0.005.
+        seed (int): Random seed for reproducibility. Defaults to 42.
+        val_split (float): Fraction of data to use for validation (0-1). Defaults to 0.2.
         visualize (bool): Whether to generate visualizations of model predictions.
+            Defaults to False.
+        resume_training (bool): If True and pretrained_model_path is provided,
+            will try to load optimizer and scheduler states as well. Defaults to False.
 
     Returns:
         None: Model weights are saved to output_dir.
+
+    Raises:
+        FileNotFoundError: If pretrained_model_path is provided but file doesn't exist.
+        RuntimeError: If there's an issue loading the pretrained model.
     """
 
+    import datetime
+
     # Set random seeds for reproducibility
     torch.manual_seed(seed)
     np.random.seed(seed)
@@ -694,9 +712,49 @@ def train_MaskRCNN_model(
     # Set up learning rate scheduler
     lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.8)
 
-    # Training loop
+    # Initialize training variables
+    start_epoch = 0
     best_iou = 0
-    for epoch in range(num_epochs):
+
+    # Load pretrained model if provided
+    if pretrained_model_path:
+        if not os.path.exists(pretrained_model_path):
+            raise FileNotFoundError(
+                f"Pretrained model file not found: {pretrained_model_path}"
+            )
+
+        print(f"Loading pretrained model from: {pretrained_model_path}")
+        try:
+            # Check if it's a full checkpoint or just model weights
+            checkpoint = torch.load(pretrained_model_path, map_location=device)
+
+            if isinstance(checkpoint, dict) and "model_state_dict" in checkpoint:
+                # It's a checkpoint with extra information
+                model.load_state_dict(checkpoint["model_state_dict"])
+
+                if resume_training:
+                    # Resume from checkpoint
+                    start_epoch = checkpoint.get("epoch", 0) + 1
+                    best_iou = checkpoint.get("best_iou", 0)
+
+                    if "optimizer_state_dict" in checkpoint:
+                        optimizer.load_state_dict(checkpoint["optimizer_state_dict"])
+
+                    if "scheduler_state_dict" in checkpoint:
+                        lr_scheduler.load_state_dict(checkpoint["scheduler_state_dict"])
+
+                    print(f"Resuming training from epoch {start_epoch}")
+                    print(f"Previous best IoU: {best_iou:.4f}")
+            else:
+                # Assume it's just the model weights
+                model.load_state_dict(checkpoint)
+
+            print("Pretrained model loaded successfully")
+        except Exception as e:
+            raise RuntimeError(f"Failed to load pretrained model: {str(e)}")
+
+    # Training loop
+    for epoch in range(start_epoch, num_epochs):
         # Train one epoch
         train_loss = train_one_epoch(model, optimizer, train_loader, device, epoch)
 
@@ -718,7 +776,7 @@ def train_MaskRCNN_model(
             torch.save(model.state_dict(), os.path.join(output_dir, "best_model.pth"))
 
         # Save checkpoint every 10 epochs
-        if (epoch + 1) % 10 == 0:
+        if (epoch + 1) % 10 == 0 or epoch == num_epochs - 1:
             torch.save(
                 {
                     "epoch": epoch,
@@ -733,6 +791,18 @@ def train_MaskRCNN_model(
     # Save final model
     torch.save(model.state_dict(), os.path.join(output_dir, "final_model.pth"))
 
+    # Save full checkpoint of final state
+    torch.save(
+        {
+            "epoch": num_epochs - 1,
+            "model_state_dict": model.state_dict(),
+            "optimizer_state_dict": optimizer.state_dict(),
+            "scheduler_state_dict": lr_scheduler.state_dict(),
+            "best_iou": best_iou,
+        },
+        os.path.join(output_dir, "final_checkpoint.pth"),
+    )
+
     # Load best model for evaluation and visualization
     model.load_state_dict(torch.load(os.path.join(output_dir, "best_model.pth")))
 
@@ -752,7 +822,23 @@ def train_MaskRCNN_model(
             num_samples=5,
             output_dir=os.path.join(output_dir, "visualizations"),
         )
-    print(f"Training complete!. Trained model saved to {output_dir}")
+
+    # Save training summary
+    with open(os.path.join(output_dir, "training_summary.txt"), "w") as f:
+        f.write(
+            f"Training completed on: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n"
+        )
+        f.write(f"Total epochs: {num_epochs}\n")
+        f.write(f"Best validation IoU: {best_iou:.4f}\n")
+        f.write(f"Final validation IoU: {final_metrics['IoU']:.4f}\n")
+        f.write(f"Final validation loss: {final_metrics['loss']:.4f}\n")
+
+        if pretrained_model_path:
+            f.write(f"Started from pretrained model: {pretrained_model_path}\n")
+            if resume_training:
+                f.write(f"Resumed training from epoch {start_epoch}\n")
+
+    print(f"Training complete! Trained model saved to {output_dir}")
 
 
 def inference_on_geotiff(

geoai/utils.py

@@ -6,6 +6,7 @@ import math
 import os
 import warnings
 import xml.etree.ElementTree as ET
+from collections import OrderedDict
 from collections.abc import Iterable
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
@@ -29,16 +30,10 @@ from rasterio.plot import show
 from rasterio.windows import Window
 from shapely.affinity import rotate
 from shapely.geometry import MultiPolygon, Polygon, box, mapping, shape
+from torchvision.models.segmentation import deeplabv3_resnet50, fcn_resnet50
 from torchvision.transforms import RandomRotation
 from tqdm import tqdm
 
-try:
-    from torchgeo.datasets import RasterDataset, unbind_samples
-except ImportError as e:
-    raise ImportError(
-        "Your torchgeo version is too old. Please upgrade to the latest version using 'pip install -U torchgeo'."
-    )
-
 
 def view_raster(
     source: str,
@@ -53,7 +48,7 @@ def view_raster(
     zoom_to_layer: Optional[bool] = True,
     visible: Optional[bool] = True,
     opacity: Optional[float] = 1.0,
-    array_args: Optional[Dict] = {},
+    array_args: Optional[Dict] = None,
     client_args: Optional[Dict] = {"cors_all": False},
     basemap: Optional[str] = "OpenStreetMap",
     basemap_args: Optional[Dict] = None,
@@ -94,6 +89,9 @@ def view_raster(
     if basemap_args is None:
         basemap_args = {}
 
+    if array_args is None:
+        array_args = {}
+
     m = leafmap.Map()
 
     if isinstance(basemap, str):
@@ -277,6 +275,14 @@ def plot_batch(
     Returns:
         None
     """
+
+    try:
+        from torchgeo.datasets import unbind_samples
+    except ImportError as e:
+        raise ImportError(
+            "Your torchgeo version is too old. Please upgrade to the latest version using 'pip install -U torchgeo'."
+        )
+
     # Get the samples and the number of items in the batch
     samples = unbind_samples(batch.copy())
 
@@ -316,9 +322,7 @@ def plot_batch(
             )
 
 
-def calc_stats(
-    dataset: RasterDataset, divide_by: float = 1.0
-) -> Tuple[np.ndarray, np.ndarray]:
+def calc_stats(dataset, divide_by: float = 1.0) -> Tuple[np.ndarray, np.ndarray]:
     """
     Calculate the statistics (mean and std) for the entire dataset.
 
@@ -1984,6 +1988,7 @@ def raster_to_vector(
     simplify_tolerance=None,
     class_values=None,
     attribute_name="class",
+    unique_attribute_value=False,
     output_format="geojson",
     plot_result=False,
 ):
@@ -1998,6 +2003,7 @@ def raster_to_vector(
         simplify_tolerance (float): Tolerance for geometry simplification. None for no simplification.
         class_values (list): Specific pixel values to vectorize. If None, all values > threshold are vectorized.
         attribute_name (str): Name of the attribute field for the class values.
+        unique_attribute_value (bool): Whether to generate unique values for each shape within a class.
         output_format (str): Format for output file - 'geojson', 'shapefile', 'gpkg'.
         plot_result (bool): Whether to plot the resulting polygons overlaid on the raster.
 
@@ -2028,7 +2034,7 @@ def raster_to_vector(
         # Process each class value
         for class_val in class_values:
             mask = masks[class_val]
-
+            shape_count = 1
             # Vectorize the mask
             for geom, value in features.shapes(
                 mask.astype(np.uint8), mask=mask, transform=transform
@@ -2045,7 +2051,14 @@ def raster_to_vector(
                     geom = geom.simplify(simplify_tolerance)
 
                 # Add to features list with class value
-                all_features.append({"geometry": geom, attribute_name: class_val})
+                if unique_attribute_value:
+                    all_features.append(
+                        {"geometry": geom, attribute_name: class_val * shape_count}
+                    )
+                else:
+                    all_features.append({"geometry": geom, attribute_name: class_val})
+
+                shape_count += 1
 
         # Create GeoDataFrame
         if all_features:
@@ -4480,8 +4493,8 @@ def region_groups(
             "area_bbox",
             "area_convex",
             "area_filled",
-            "major_length",
-            "minor_length",
+            "axis_major_length",
+            "axis_minor_length",
             "eccentricity",
             "diameter_areagth",
             "extent",
@@ -4578,7 +4591,7 @@ def region_groups(
     )
 
     df = pd.DataFrame(props)
-    df["elongation"] = df["major_length"] / df["minor_length"]
+    df["elongation"] = df["axis_major_length"] / df["axis_minor_length"]
 
     dtype = "uint8"
     if num_labels > 255 and num_labels <= 65535:
@@ -4595,9 +4608,29 @@ def region_groups(
         da.values = label_image
         if out_image is not None:
             da.rio.to_raster(out_image, dtype=dtype)
-            if out_vector is not None:
-                tmp_vector = temp_file_path(".gpkg")
-                raster_to_vector(out_image, tmp_vector)
+
+        if out_vector is not None:
+            tmp_raster = None
+            tmp_vector = None
+            try:
+                if out_image is None:
+                    tmp_raster = temp_file_path(".tif")
+                    da.rio.to_raster(tmp_raster, dtype=dtype)
+                    tmp_vector = temp_file_path(".gpkg")
+                    raster_to_vector(
+                        tmp_raster,
+                        tmp_vector,
+                        attribute_name="value",
+                        unique_attribute_value=True,
+                    )
+                else:
+                    tmp_vector = temp_file_path(".gpkg")
+                    raster_to_vector(
+                        out_image,
+                        tmp_vector,
+                        attribute_name="value",
+                        unique_attribute_value=True,
+                    )
                 gdf = gpd.read_file(tmp_vector)
                 gdf["label"] = gdf["value"].astype(int)
                 gdf.drop(columns=["value"], inplace=True)
@@ -4605,6 +4638,15 @@ def region_groups(
                 gdf2.to_file(out_vector)
                 gdf2.sort_values("label", inplace=True)
                 df = gdf2
+            finally:
+                try:
+                    if tmp_raster is not None and os.path.exists(tmp_raster):
+                        os.remove(tmp_raster)
+                    if tmp_vector is not None and os.path.exists(tmp_vector):
+                        os.remove(tmp_vector)
+                except Exception as e:
+                    print(f"Warning: Failed to delete temporary files: {str(e)}")
+
         return da, df
 
 
@@ -5667,11 +5709,14 @@ def orthogonalize(
         crs = src.crs
 
         # Extract shapes from the raster mask
-        shapes = features.shapes(mask, transform=transform)
+        shapes = list(features.shapes(mask, transform=transform))
+
+        # Initialize progress bar
+        print(f"Processing {len(shapes)} features...")
 
         # Convert shapes to GeoJSON features
         features_list = []
-        for shape, value in shapes:
+        for shape, value in tqdm(shapes, desc="Converting features", unit="shape"):
             if value > 0:  # Only process non-zero values (actual objects)
                 # Convert GeoJSON geometry to Shapely polygon
                 polygon = Polygon(shape["coordinates"][0])
@@ -5811,6 +5856,200 @@ def orthogonalize(
 
         # Save to file if output_path is provided
         if output_path:
+            print(f"Saving to {output_path}...")
             gdf.to_file(output_path)
+            print("Done!")
 
         return gdf
+
+
+def inspect_pth_file(pth_path):
+    """
+    Inspect a PyTorch .pth model file to determine its architecture.
+
+    Args:
+        pth_path: Path to the .pth file to inspect
+
+    Returns:
+        Information about the model architecture
+    """
+    # Check if file exists
+    if not os.path.exists(pth_path):
+        print(f"Error: File {pth_path} not found")
+        return
+
+    # Load the checkpoint
+    try:
+        checkpoint = torch.load(pth_path, map_location=torch.device("cpu"))
+        print(f"\n{'='*50}")
+        print(f"Inspecting model file: {pth_path}")
+        print(f"{'='*50}\n")
+
+        # Check if it's a state_dict or a complete model
+        if isinstance(checkpoint, OrderedDict) or isinstance(checkpoint, dict):
+            if "state_dict" in checkpoint:
+                print("Found 'state_dict' key in the checkpoint.")
+                state_dict = checkpoint["state_dict"]
+            elif "model_state_dict" in checkpoint:
+                print("Found 'model_state_dict' key in the checkpoint.")
+                state_dict = checkpoint["model_state_dict"]
+            else:
+                print("Assuming file contains a direct state_dict.")
+                state_dict = checkpoint
+
+            # Print the keys in the checkpoint
+            print("\nCheckpoint contains the following keys:")
+            for key in checkpoint.keys():
+                if isinstance(checkpoint[key], dict):
+                    print(f"- {key} (dictionary with {len(checkpoint[key])} items)")
+                elif isinstance(checkpoint[key], (torch.Tensor, list, tuple)):
+                    print(
+                        f"- {key} (shape/size: {len(checkpoint[key]) if isinstance(checkpoint[key], (list, tuple)) else checkpoint[key].shape})"
+                    )
+                else:
+                    print(f"- {key} ({type(checkpoint[key]).__name__})")
+
+            # Try to infer the model architecture from the state_dict keys
+            print("\nAnalyzing model architecture from state_dict...")
+
+            # Extract layer keys for analysis
+            layer_keys = list(state_dict.keys())
+
+            # Print the first few layer keys to understand naming pattern
+            print("\nFirst 10 layer names in state_dict:")
+            for i, key in enumerate(layer_keys[:10]):
+                shape = state_dict[key].shape
+                print(f"- {key} (shape: {shape})")
+
+            # Look for architecture indicators in the keys
+            architecture_indicators = {
+                "conv": 0,
+                "bn": 0,
+                "layer": 0,
+                "fc": 0,
+                "backbone": 0,
+                "encoder": 0,
+                "decoder": 0,
+                "unet": 0,
+                "resnet": 0,
+                "classifier": 0,
+                "deeplab": 0,
+                "fcn": 0,
+            }
+
+            for key in layer_keys:
+                for indicator in architecture_indicators:
+                    if indicator in key.lower():
+                        architecture_indicators[indicator] += 1
+
+            print("\nArchitecture indicators found in layer names:")
+            for indicator, count in architecture_indicators.items():
+                if count > 0:
+                    print(f"- '{indicator}' appears {count} times")
+
+            # Count total parameters
+            total_params = sum(p.numel() for p in state_dict.values())
+            print(f"\nTotal parameters: {total_params:,}")
+
+            # Try to load the model with different architectures
+            print("\nAttempting to match with common architectures...")
+
+            # Try to identify if it's a segmentation model
+            if any("out" in k or "classifier" in k for k in layer_keys):
+                print("Model appears to be a segmentation model.")
+
+                # Check if it might be a UNet
+                if (
+                    architecture_indicators["encoder"] > 0
+                    and architecture_indicators["decoder"] > 0
+                ):
+                    print(
+                        "Architecture seems to be a UNet-based model with encoder-decoder structure."
+                    )
+                # Check for FCN or DeepLab indicators
+                elif architecture_indicators["fcn"] > 0:
+                    print(
+                        "Architecture seems to be FCN-based (Fully Convolutional Network)."
+                    )
+                elif architecture_indicators["deeplab"] > 0:
+                    print("Architecture seems to be DeepLab-based.")
+                elif architecture_indicators["backbone"] > 0:
+                    print(
+                        "Model has a backbone architecture, likely a modern segmentation model."
+                    )
+
+            # Try to infer output classes from the final layer
+            output_layer_keys = [
+                k for k in layer_keys if "classifier" in k or k.endswith(".out.weight")
+            ]
+            if output_layer_keys:
+                output_shape = state_dict[output_layer_keys[0]].shape
+                if len(output_shape) >= 2:
+                    num_classes = output_shape[0]
+                    print(f"\nModel likely has {num_classes} output classes.")
+
+            print("\nSUMMARY:")
+            print("The model appears to be", end=" ")
+            if architecture_indicators["unet"] > 0:
+                print("a UNet architecture.", end=" ")
+            elif architecture_indicators["fcn"] > 0:
+                print("an FCN architecture.", end=" ")
+            elif architecture_indicators["deeplab"] > 0:
+                print("a DeepLab architecture.", end=" ")
+            elif architecture_indicators["resnet"] > 0:
+                print("ResNet-based.", end=" ")
+            else:
+                print("a custom architecture.", end=" ")
+
+            # Try to load with common models
+            try_common_architectures(state_dict)
+
+        else:
+            print(
+                "The file contains an entire model object rather than just a state dictionary."
+            )
+            # If it's a complete model, we can directly examine its architecture
+            print(checkpoint)
+
+    except Exception as e:
+        print(f"Error loading the model file: {str(e)}")
+
+
+def try_common_architectures(state_dict):
+    """
+    Try to load the state_dict into common architectures to see which one fits.
+
+    Args:
+        state_dict: The model's state dictionary
+    """
+    import torchinfo
+
+    # Test models and their initializations
+    models_to_try = {
+        "FCN-ResNet50": lambda: fcn_resnet50(num_classes=9),
+        "DeepLabV3-ResNet50": lambda: deeplabv3_resnet50(num_classes=9),
+    }
+
+    print("\nTrying to load state_dict into common architectures:")
+
+    for name, model_fn in models_to_try.items():
+        try:
+            model = model_fn()
+            # Sometimes state_dict keys have 'model.' prefix
+            if all(k.startswith("model.") for k in state_dict.keys()):
+                cleaned_state_dict = {k[6:]: v for k, v in state_dict.items()}
+                model.load_state_dict(cleaned_state_dict, strict=False)
+            else:
+                model.load_state_dict(state_dict, strict=False)
+
+            print(
+                f"- {name}: Successfully loaded (may have missing or unexpected keys)"
+            )
+
+            # Generate model summary
+            print(f"\nSummary of {name} architecture:")
+            summary = torchinfo.summary(model, input_size=(1, 3, 224, 224), verbose=0)
+            print(summary)
+
+        except Exception as e:
+            print(f"- {name}: Failed to load - {str(e)}")

{geoai_py-0.4.0.dist-info → geoai_py-0.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: geoai-py
-Version: 0.4.0
+Version: 0.4.2
 Summary: A Python package for using Artificial Intelligence (AI) with geospatial data
 Author-email: Qiusheng Wu <giswqs@gmail.com>
 License: MIT License
@@ -34,15 +34,12 @@ Requires-Dist: scikit-image
 Requires-Dist: scikit-learn
 Requires-Dist: torch
 Requires-Dist: torchgeo
+Requires-Dist: torchinfo
 Requires-Dist: tqdm
 Requires-Dist: transformers
-Provides-Extra: download
-Requires-Dist: pystac_client; extra == "download"
-Requires-Dist: planetary_computer; extra == "download"
-Requires-Dist: tqdm; extra == "download"
-Requires-Dist: overturemaps; extra == "download"
-Provides-Extra: all
-Requires-Dist: geoai[download]; extra == "all"
+Provides-Extra: extra
+Requires-Dist: overturemaps; extra == "extra"
+Dynamic: license-file
 
 # GeoAI: Artificial Intelligence for Geospatial Data
 
@@ -54,6 +51,8 @@ Requires-Dist: geoai[download]; extra == "all"
 [![image](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![image](https://img.shields.io/badge/YouTube-Tutorials-red)](https://bit.ly/GeoAI-Tutorials)
 
+[![logo](https://raw.githubusercontent.com/opengeos/geoai/master/docs/assets/logo_rect.png)](https://github.com/opengeos/geoai/blob/master/docs/assets/logo.png)
+
 **A powerful Python package for integrating Artificial Intelligence with geospatial data analysis and visualization**
 
 GeoAI bridges the gap between AI and geospatial analysis, providing tools for processing, analyzing, and visualizing geospatial data using advanced machine learning techniques. Whether you're working with satellite imagery, LiDAR point clouds, or vector data, GeoAI offers intuitive interfaces to apply cutting-edge AI models.
@@ -144,7 +143,3 @@ We welcome contributions of all kinds! See our [contributing guide](https://geoa
 ## 📄 License
 
 GeoAI is free and open source software, licensed under the MIT License.
-
-## 💖 Acknowledgment
-
-Some of the pre-trained models used in the geoai package are adapted from the [ArcGIS Living Atlas](https://livingatlas.arcgis.com/en/browse/?q=dlpk#d=2&q=dlpk). Credits to Esri for making these models available.

geoai_py-0.4.2.dist-info/RECORD

@@ -0,0 +1,15 @@
+geoai/__init__.py,sha256=kHB6b3uOdCoxMpIpfpXtPxg-KJQVsKJveb8zTw5Mxzs,3592
+geoai/download.py,sha256=SE81OrhH2XSH02xtAXQyh5ltBqA8K7ksGT1Lm6SMqx8,37593
+geoai/extract.py,sha256=bR8TkUXncW0rinsBO5oxlVFGsSVoj6xnm5xdDc-J1Xk,115490
+geoai/geoai.py,sha256=qY1HWmJQ0ZgIPtlgWd4gpuCGw6dovdg8D5pAtHqfr8U,334
+geoai/hf.py,sha256=mLKGxEAS5eHkxZLwuLpYc1o7e3-7QIXdBv-QUY-RkFk,17072
+geoai/segment.py,sha256=g3YW17ftr--CKq6VB32TJEPY8owGQ7uQ0sg_tUT2ooE,13681
+geoai/segmentation.py,sha256=AtPzCvguHAEeuyXafa4bzMFATvltEYcah1B8ZMfkM_s,11373
+geoai/train.py,sha256=-l2j1leTxDnFDLaBslu1q6CobXjm3LEdiQwUWOU8P6M,40088
+geoai/utils.py,sha256=Wg9jbMBKUZSGUmU8Vkp6v19QcDNg5KmcyZxuHqJvgnc,233016
+geoai_py-0.4.2.dist-info/licenses/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
+geoai_py-0.4.2.dist-info/METADATA,sha256=Sc6m-MyCti-_Dnan5wp6GIy88LwuBAF_IYrFF34SRJE,6049
+geoai_py-0.4.2.dist-info/WHEEL,sha256=9bhjOwO--Rs91xaPcBdlYFUmIudhuXqFlPriQeYQITw,109
+geoai_py-0.4.2.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
+geoai_py-0.4.2.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
+geoai_py-0.4.2.dist-info/RECORD,,

{geoai_py-0.4.0.dist-info → geoai_py-0.4.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (77.0.1)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

geoai_py-0.4.0.dist-info/RECORD

@@ -1,15 +0,0 @@
-geoai/__init__.py,sha256=rtBuAkA1JMtY_o_PE3kdaFftrp5K9YBQxdi5y99ktPU,923
-geoai/download.py,sha256=eqMecJqvqyrIVFViNA7pW8a5EIhqYJzRILmxQoFHG2k,13095
-geoai/extract.py,sha256=CCXjUcGC4ZOKOKKjvElp8VFmTz46b0ATvGitbOPgTwE,95506
-geoai/geoai.py,sha256=L1jkozDcjqJXvqT6i8oW04Ix9x4cc2-LNYi9_564ABQ,163
-geoai/hf.py,sha256=mLKGxEAS5eHkxZLwuLpYc1o7e3-7QIXdBv-QUY-RkFk,17072
-geoai/segment.py,sha256=g3YW17ftr--CKq6VB32TJEPY8owGQ7uQ0sg_tUT2ooE,13681
-geoai/segmentation.py,sha256=AtPzCvguHAEeuyXafa4bzMFATvltEYcah1B8ZMfkM_s,11373
-geoai/train.py,sha256=VaeFzIkVUNTdre8ImgUNhmbpA42qijSXaajLpmBF_Ic,36248
-geoai/utils.py,sha256=Q5f-mFVjer7BKipt4GOI9QFvTRsdB8V48LpkqlfBg2o,223437
-geoai_py-0.4.0.dist-info/LICENSE,sha256=vN2L5U7cZ6ZkOHFmc8WiGlsogWsZc5dllMeNxnKVOZg,1070
-geoai_py-0.4.0.dist-info/METADATA,sha256=xRCruLClbNxRuXn3A-729IWqiyO-B08VFbpMvrN-ErI,6297
-geoai_py-0.4.0.dist-info/WHEEL,sha256=SrDKpSbFN1G94qcmBqS9nyHcDMp9cUS9OC06hC0G3G0,109
-geoai_py-0.4.0.dist-info/entry_points.txt,sha256=uGp3Az3HURIsRHP9v-ys0hIbUuBBNUfXv6VbYHIXeg4,41
-geoai_py-0.4.0.dist-info/top_level.txt,sha256=1YkCUWu-ii-0qIex7kbwAvfei-gos9ycyDyUCJPNWHY,6
-geoai_py-0.4.0.dist-info/RECORD,,