geowatch
  • geowatch
    • geowatch package
      • Subpackages
        • geowatch.cli package
          • Subpackages
            • geowatch.cli.experimental package
              • Submodules
                • geowatch.cli.experimental.disk_info module
                  • DiskInfoCLI
                    • DiskInfoCLI.main()
                    • DiskInfoCLI.default
                  • main()
                • geowatch.cli.experimental.find_recent_checkpoint module
                  • FindRecentCheckpointCLI
                    • FindRecentCheckpointCLI.main()
                    • FindRecentCheckpointCLI.default
                  • main()
                • geowatch.cli.experimental.fixup_predict_kwcoco_metadata module
                  • FixupPredictKwcocoMetadata
                    • FixupPredictKwcocoMetadata.main()
                    • FixupPredictKwcocoMetadata.default
                  • fixup_pxl_pred_node_dpath()
                  • main()
                • geowatch.cli.experimental.recommend_size_adjustments module
                  • RecommendSizeAdjustmentsCLI
                    • RecommendSizeAdjustmentsCLI.main()
                    • RecommendSizeAdjustmentsCLI.default
                  • main()
                • geowatch.cli.experimental.unpack_model module
                  • UnpackModelCLI
                    • UnpackModelCLI.main()
                    • UnpackModelCLI.default
                  • unpack_model()
                  • extract_package_contents()
              • Module contents
            • geowatch.cli.queue_cli package
              • Submodules
                • geowatch.cli.queue_cli.prepare_cold_transfer module
                  • PrepareColdTransferConfig
                    • PrepareColdTransferConfig.default
                  • main()
                • geowatch.cli.queue_cli.prepare_splits module
                  • PrepareSplitsConfig
                    • PrepareSplitsConfig.default
                  • prep_splits()
                  • main()
                • geowatch.cli.queue_cli.prepare_ta2_dataset module
                  • PrepareTA2Config
                    • PrepareTA2Config.default
                    • PrepareTA2Config.main()
                  • main()
                • geowatch.cli.queue_cli.prepare_teamfeats module
                  • TeamFeaturePipelineConfig
                    • TeamFeaturePipelineConfig.default
                  • prep_feats()
                  • main()
                • geowatch.cli.queue_cli.prepare_time_combined_dataset module
                  • PrepareTimeAverages
                    • PrepareTimeAverages.default
                  • main()
              • Module contents
            • geowatch.cli.smartflow package
              • Submodules
                • geowatch.cli.smartflow.run_bas_datagen module
                  • BASDatasetConfig
                    • BASDatasetConfig.default
                    • BASDatasetConfig.normalize()
                  • main()
                  • build_combined_stac()
                  • input_stac_to_kwcoco()
                  • run_stac_to_cropped_kwcoco()
                • geowatch.cli.smartflow.run_bas_fusion module
                  • BasFusionConfig
                    • BasFusionConfig.default
                  • main()
                  • run_bas_fusion_for_baseline()
                • geowatch.cli.smartflow.run_bas_fusion_incremental module
                  • BasFusionConfig
                    • BasFusionConfig.default
                  • main()
                  • filter_kwcoco_images_by_datetime()
                  • run_bas_fusion_for_baseline()
                • geowatch.cli.smartflow.run_dino_sv module
                  • DinoSVConfig
                    • DinoSVConfig.default
                  • main()
                  • run_dino_sv()
                • geowatch.cli.smartflow.run_dzyne_parallel_site_vali module
                  • DzyneParallelSiteValiConfig
                    • DzyneParallelSiteValiConfig.default
                  • main()
                  • run_dzyne_parallel_site_vali_for_baseline()
                • geowatch.cli.smartflow.run_fixups module
                  • FixupConfig
                    • FixupConfig.default
                  • main()
                • geowatch.cli.smartflow.run_iarpa_metrics module
                  • RunIARPAMetricsCLI
                    • RunIARPAMetricsCLI.main()
                    • RunIARPAMetricsCLI.default
                  • main()
                • geowatch.cli.smartflow.run_pseudolive_consolidate module
                  • PseudoliveConsolidateConfig
                    • PseudoliveConsolidateConfig.default
                  • main()
                  • run_pseudolive_consolidate()
                • geowatch.cli.smartflow.run_psuedolive_copy_previous module
                  • PsuedoliveCopyPreviousConfig
                    • PsuedoliveCopyPreviousConfig.default
                  • main()
                  • run_copy_previous_region_model()
                • geowatch.cli.smartflow.run_sc_datagen module
                  • ACSCDatasetConfig
                    • ACSCDatasetConfig.default
                  • main()
                  • run_generate_acsc_cropped_kwcoco()
                • geowatch.cli.smartflow.run_sc_fusion module
                  • SCFusionConfig
                    • SCFusionConfig.default
                  • main()
                  • run_sc_fusion_for_baseline()
                • geowatch.cli.smartflow.run_sv_datagen module
                  • SVDatasetConfig
                    • SVDatasetConfig.default
                  • main()
                  • run_generate_sv_cropped_kwcoco()
                • geowatch.cli.smartflow.run_teamfeat_acsc_landcover module
                  • TeamFeatLandcover
                    • TeamFeatLandcover.default
                  • main()
                • geowatch.cli.smartflow.run_teamfeat_cold module
                  • TeamFeatColdConfig
                    • TeamFeatColdConfig.default
                  • main()
                • geowatch.cli.smartflow.run_teamfeat_invariants module
                  • TeamFeatInvariantsConfig
                    • TeamFeatInvariantsConfig.default
                  • main()
                  • run_uky_invariants_for_baseline()
                • geowatch.cli.smartflow.run_teamfeat_landcover module
                  • TeamFeatLandcoverConfig
                    • TeamFeatLandcoverConfig.default
                  • main()
                  • run_landcover_for_baseline()
                • geowatch.cli.smartflow.run_teamfeat_mae module
                  • TeamFeatMAE
                    • TeamFeatMAE.default
                  • main()
                • geowatch.cli.smartflow.run_upload_to_rgd module
                  • UploadRGDConfig
                    • UploadRGDConfig.default
                  • main()
                  • get_model_results()
                  • upload_to_rgd()
                  • post_site()
              • Module contents
            • geowatch.cli.special package
              • Submodules
                • geowatch.cli.special.finish_install module
                  • FinishInstallCLI
                    • FinishInstallCLI.main()
                    • FinishInstallCLI.default
                  • parse_requirements()
                  • main()
              • Module contents
          • Submodules
            • geowatch.cli.animate_visualizations module
              • animate_visualizations()
            • geowatch.cli.baseline_framework_ingress module
              • BaselineFrameworkIngressConfig
                • BaselineFrameworkIngressConfig.default
                • BaselineFrameworkIngressConfig.normalize()
              • main()
              • baseline_framework_ingress()
              • read_input_stac_items()
              • load_input_stac_items()
            • geowatch.cli.cluster_sites module
              • ClusterSiteConfig
                • ClusterSiteConfig.default
                • ClusterSiteConfig.main()
              • main()
              • cluster_single_region_sites()
              • build_clustered_models()
            • geowatch.cli.coco_add_ignore_buffer module
              • CocoAddIgnoreBufferConfig
                • CocoAddIgnoreBufferConfig.default
              • main()
            • geowatch.cli.coco_add_watch_fields module
              • AddWatchFieldsConfig
                • AddWatchFieldsConfig.default
                • AddWatchFieldsConfig.normalize()
              • main()
            • geowatch.cli.coco_align module
              • AssetExtractConfig
                • AssetExtractConfig.default
                • AssetExtractConfig.normalize()
              • ImageExtractConfig
                • ImageExtractConfig.default
              • ExtractConfig
                • ExtractConfig.default
                • ExtractConfig.normalize()
              • CocoAlignGeotiffConfig
                • CocoAlignGeotiffConfig.default
              • main()
              • SimpleDataCube
                • SimpleDataCube.demo()
                • SimpleDataCube.query_image_overlaps()
                • SimpleDataCube.extract_overlaps()
              • extract_image_job()
              • serialize_kwimage_boxes()
              • SkipImage
            • geowatch.cli.coco_average_features module
              • CocoAverageFeaturesConfig
                • CocoAverageFeaturesConfig.default
              • split_channel_names_by_grammar()
              • check_kwcoco_file()
              • merge_kwcoco_channels()
              • main()
            • geowatch.cli.coco_clean_geotiffs module
              • CleanGeotiffConfig
                • CleanGeotiffConfig.default
              • main()
              • probe_image_issues()
              • probe_asset()
              • probe_asset_imdata()
              • probe_band_imdata()
              • fix_single_asset()
              • fix_geotiff_ondisk()
              • draw_asset_summary()
            • geowatch.cli.coco_combine_features module
              • CocoCombineFeatures
                • CocoCombineFeatures.default
              • main()
              • combine_auxiliary_features()
              • associate_images()
            • geowatch.cli.coco_crop_tracks module
              • CocoCropTrackConfig
                • CocoCropTrackConfig.default
              • main()
              • make_track_kwcoco_manifest()
              • generate_crop_jobs()
              • run_crop_asset_task()
            • geowatch.cli.coco_reformat_channels module
              • CocoReformatChannels
                • CocoReformatChannels.default
              • main()
              • reformat_obj()
              • schedule_quantization()
            • geowatch.cli.coco_remove_bad_images module
              • CocoRemoveBadImagesConfig
                • CocoRemoveBadImagesConfig.default
              • main()
              • compute_asset_disk_usage()
              • is_image_empty()
              • find_empty_images()
            • geowatch.cli.coco_spectra module
              • CocoSpectraConfig
                • CocoSpectraConfig.default
              • HistAccum
                • HistAccum.update()
                • HistAccum.finalize()
              • main()
              • single_persensor_table()
              • sensor_stats_tables()
              • ensure_intensity_sidecar()
              • ensure_intensity_stats()
              • plot_intensity_histograms()
            • geowatch.cli.coco_time_combine module
              • TimeCombineConfig
                • TimeCombineConfig.default
              • main()
              • combine_kwcoco_channels_temporally()
              • get_quality_mask()
              • estimate_top_quality_images()
              • merge_images()
              • generate_frames()
              • filter_image_ids_by_season()
            • geowatch.cli.coco_update_geotiff_metadata module
              • UpdateGeotiffMetadataConfig
                • UpdateGeotiffMetadataConfig.default
              • main()
            • geowatch.cli.coco_visualize_videos module
              • CocoVisualizeConfig
                • CocoVisualizeConfig.default
              • main()
              • SkipFrame
              • SkipChanGroup
              • video_track_info()
              • TrackInfoLookup
                • TrackInfoLookup.get_track_trail_by_video_id()
              • select_fixed_normalization()
              • draw_chan_group()
              • draw_polyline_on_image()
            • geowatch.cli.collect_env module
              • CollectEnvCLI
                • CollectEnvCLI.main()
                • CollectEnvCLI.default
              • get_pip_packages()
              • run_and_read_all()
              • main()
            • geowatch.cli.concat_kwcoco_videos module
              • main()
              • concat_kwcoco_datasets()
            • geowatch.cli.crop_sites_to_regions module
              • SiteFilterConfig
                • SiteFilterConfig.default
              • CropSitesToRegionsConfig
                • CropSitesToRegionsConfig.default
              • main()
              • filter_sites()
              • filter_gdf_in_utm()
            • geowatch.cli.draw_region module
              • DrawRegionCLI
                • DrawRegionCLI.main()
                • DrawRegionCLI.default
              • main()
            • geowatch.cli.extend_sc_sites module
              • default_feat()
              • to_date()
              • extend()
              • extend_clone()
              • create()
              • main()
            • geowatch.cli.find_dvc module
              • FindDVCConfig
                • FindDVCConfig.main()
                • FindDVCConfig.default
            • geowatch.cli.fit module
              • FitCLI
                • FitCLI.main()
                • FitCLI.default
              • main()
            • geowatch.cli.fix_region_models module
              • FixRegionModelsCLI
                • FixRegionModelsCLI.default
              • fakefloat
              • DecimalEncoder
                • DecimalEncoder.default()
              • defaultencode()
              • main()
              • special_dumps()
              • fix_region_model()
            • geowatch.cli.geojson_site_stats module
              • GeojsonSiteStatsConfig
                • GeojsonSiteStatsConfig.default
                • GeojsonSiteStatsConfig.main()
              • main()
              • gdf_site_overlaps()
              • viz_site_stats()
              • geopandas_shape_stats()
            • geowatch.cli.geotiffs_to_kwcoco module
              • KWCocoFromGeotiffConfig
                • KWCocoFromGeotiffConfig.default
              • main()
              • filter_band_files()
              • ingest_landsat_directory()
              • ingest_sentinel2_directory()
              • make_coco_img_from_geotiff()
              • make_coco_img_from_auxiliary_geotiffs()
              • make_coco_img_from_auxiliary_dicts()
              • find_geotiffs()
            • geowatch.cli.merge_region_models module
              • MergeRegionModelConfig
                • MergeRegionModelConfig.default
              • main()
              • combine_region_models()
            • geowatch.cli.mlops_cli module
            • geowatch.cli.predict module
              • PredictCLI
                • PredictCLI.main()
                • PredictCLI.default
              • main()
            • geowatch.cli.pseudolive_consolidate module
              • main()
              • reindex_ids()
              • pseudolive_consolidate()
              • compute_iou()
            • geowatch.cli.reproject_annotations module
              • ReprojectAnnotationsConfig
                • ReprojectAnnotationsConfig.default
                • ReprojectAnnotationsConfig.main()
                • ReprojectAnnotationsConfig.normalize()
              • main()
              • check_sitemodel_assumptions()
              • separate_region_model_types()
              • expand_site_models_with_site_summaries()
              • make_pseudo_sitemodels()
              • validate_site_dataframe()
              • assign_sites_to_images()
              • propogate_site()
              • keyframe_interpolate()
              • plot_poc_keyframe_interpolate()
              • plot_image_and_site_times()
              • draw_geospace()
              • is_nonish()
            • geowatch.cli.run_fusion_predict module
            • geowatch.cli.run_metrics_framework module
              • MetricsConfig
                • MetricsConfig.default
                • MetricsConfig.main()
              • ensure_thumbnails()
              • main()
            • geowatch.cli.run_tracker module
              • KWCocoToGeoJSONConfig
                • KWCocoToGeoJSONConfig.default
              • coco_create_observation()
              • predict_phase_changes()
              • smooth_observation_scores()
              • classify_site()
              • coco_create_site_header()
              • convert_kwcoco_to_iarpa()
              • coco_track_to_site()
              • assign_sites_to_videos()
              • add_site_summary_to_kwcoco()
              • main()
              • coco_video_gdf()
              • assign_videos_to_regions()
              • coco_remove_out_of_bound_tracks()
              • demo()
            • geowatch.cli.smartflow_egress module
              • SmartflowEgressConfig
                • SmartflowEgressConfig.default
              • main()
              • smartflow_egress_with_arg_processing()
              • smartflow_egress()
              • fallback_copy()
            • geowatch.cli.smartflow_ingress module
              • SmartflowIngressConfig
                • SmartflowIngressConfig.default
              • main()
              • smartflow_ingress()
            • geowatch.cli.split_videos module
              • SplitVideoConfig
                • SplitVideoConfig.default
              • main()
            • geowatch.cli.stac_search module
              • StacSearchConfig
                • StacSearchConfig.default
              • main()
              • StacSearcher
                • StacSearcher.by_geometry()
                • StacSearcher.by_id()
              • area_query()
            • geowatch.cli.stac_to_kwcoco module
              • StacToCocoConfig
                • StacToCocoConfig.default
              • main()
              • normalize_str()
              • make_coco_aux_from_stac_asset()
              • stac_to_kwcoco()
              • summarize_stac_item()
            • geowatch.cli.torch_model_stats module
              • TorchModelStatsConfig
                • TorchModelStatsConfig.default
              • main()
              • torch_checkpoint_stats()
              • torch_model_stats()
              • fallback()
            • geowatch.cli.validate_annotation_schemas module
              • ValidateAnnotationConfig
                • ValidateAnnotationConfig.default
                • ValidateAnnotationConfig.main()
              • main()
              • validate_data_contents()
              • validate_schemas()
              • validate_region_model_content()
              • validate_site_content()
            • geowatch.cli.watch_coco_stats module
              • WatchCocoStats
                • WatchCocoStats.main()
                • WatchCocoStats.default
              • coco_watch_stats()
              • build_year_summary()
              • coco_sensorchan_gsd_stats()
              • main()
          • Module contents
        • geowatch.demo package
          • Subpackages
            • geowatch.demo.metrics_demo package
              • Submodules
                • geowatch.demo.metrics_demo.demo_rendering module
                  • render_toy_georeferenced_image()
                  • write_demo_geotiff()
                • geowatch.demo.metrics_demo.demo_truth module
                  • RegionModelGenerator
                  • SiteModelGenerator
                    • SiteModelGenerator.SITE_PHASES
                  • random_region_model()
                  • random_observables()
                  • random_site_model()
                  • make_site_summary()
                • geowatch.demo.metrics_demo.demo_utils module
                  • random_geo_points()
                  • random_geo_polygon()
                  • random_time_sequence()
                  • utm_epsg_from_latlon()
                  • project_gdf_to_local_utm()
                  • find_local_meter_epsg_crs()
                  • get_crs84()
                • geowatch.demo.metrics_demo.generate_demodata module
                  • generate_demo_metrics_framework_data()
                • geowatch.demo.metrics_demo.site_perterbing module
                  • perterb_site_model()
                  • PerterbModel
                    • PerterbModel.perterb_single_site()
                  • perterb_single_site_model()
              • Module contents
          • Submodules
            • geowatch.demo.demo_region module
              • demo_khq_annots()
              • demo_smart_annots()
              • demo_khq_region_fpath()
              • demo_smart_region_fpath()
            • geowatch.demo.dummy_demodata module
              • dummy_rpc_geotiff_fpath()
            • geowatch.demo.landsat_demodata module
              • grab_landsat_product()
            • geowatch.demo.nitf_demodata module
              • grab_nitf_fpath()
            • geowatch.demo.sentinel2_demodata module
              • bands_sentinel2()
              • grab_sentinel2_product()
            • geowatch.demo.smart_kwcoco_demodata module
              • coerce_kwcoco()
              • demo_kwcoco_multisensor()
              • demo_kwcoco_with_heatmaps()
              • hack_in_heatmaps()
              • hack_in_timedata()
              • hack_seed_geometadata_in_dset()
              • random_inscribed_polygon()
              • demo_dataset_with_regions_and_sites()
            • geowatch.demo.stac_demo module
              • demo()
          • Module contents
            • coerce_kwcoco()
            • demo()
            • demo_kwcoco_multisensor()
            • demo_kwcoco_with_heatmaps()
            • dummy_rpc_geotiff_fpath()
            • grab_landsat_product()
            • grab_nitf_fpath()
            • grab_sentinel2_product()
            • hack_seed_geometadata_in_dset()
        • geowatch.geoannots package
          • Submodules
            • geowatch.geoannots.geococo_objects module
              • CocoGeoVideo
                • CocoGeoVideo.warp_vid_from_wld
                • CocoGeoVideo.warp_wld_from_vid
                • CocoGeoVideo.images
                • CocoGeoVideo.corners()
                • CocoGeoVideo.wld_crs
                • CocoGeoVideo.wld_corners_gdf
            • geowatch.geoannots.geomodels module
              • RegionModel
                • RegionModel.info()
                • RegionModel.load_schema()
                • RegionModel.site_summaries()
                • RegionModel.coerce()
                • RegionModel.pandas_summaries()
                • RegionModel.pandas_region()
                • RegionModel.pandas_header()
                • RegionModel.pandas_body()
                • RegionModel.random()
                • RegionModel.add_site_summary()
                • RegionModel.region_id
                • RegionModel.fixup()
                • RegionModel.fix_multipolygons()
                • RegionModel.remove_invalid_properties()
                • RegionModel.ensure_comments()
                • RegionModel.infer_header()
              • SiteModel
                • SiteModel.info()
                • SiteModel.load_schema()
                • SiteModel.header
                • SiteModel.observations()
                • SiteModel.pandas_observations()
                • SiteModel.pandas_site()
                • SiteModel.pandas_header()
                • SiteModel.pandas_body()
                • SiteModel.random()
                • SiteModel.as_summary()
                • SiteModel.region_id
                • SiteModel.site_id
                • SiteModel.status
                • SiteModel.fix_geom()
                • SiteModel.fix_sensor_names()
                • SiteModel.fix_current_phase_salient()
                • SiteModel.fix_multipolygons()
                • SiteModel.fixup()
                • SiteModel.fix_aliased_properties()
                • SiteModel.fix_old_schema_properties()
                • SiteModel.ensure_isodates()
                • SiteModel.clamp_scores()
                • SiteModel.remove_invalid_properties()
              • Point
              • RegionHeader
                • RegionHeader.empty()
                • RegionHeader.coerce()
                • RegionHeader.ensure_isodates()
              • SiteSummary
                • SiteSummary.from_geopandas_frame()
                • SiteSummary.as_site()
                • SiteSummary.fixup()
                • SiteSummary.coerce()
                • SiteSummary.random()
              • SiteHeader
                • SiteHeader.empty()
                • SiteHeader.as_summary()
                • SiteHeader.coerce()
                • SiteHeader.random()
              • Observation
                • Observation.coerce()
                • Observation.observation_date
                • Observation.random()
                • Observation.empty()
              • ModelCollection
                • ModelCollection.fixup()
                • ModelCollection.validate()
              • PointModelCollection
              • SiteModelCollection
                • SiteModelCollection.as_region_model()
                • SiteModelCollection.to_point_model()
                • SiteModelCollection.coerce()
              • PointModel
              • handle_error()
              • coerce_site_or_region_model()
          • Module contents
        • geowatch.gis package
          • Subpackages
            • geowatch.gis.sensors package
              • Submodules
                • geowatch.gis.sensors.sentinel2 module
              • Module contents
                • sentinel2_grid()
          • Submodules
            • geowatch.gis.digital_globe module
            • geowatch.gis.elevation module
            • geowatch.gis.geotiff module
            • geowatch.gis.spatial_reference module
          • Module contents
        • geowatch.mlops package
          • Submodules
            • geowatch.mlops.aggregate module
              • AggregateLoader
                • AggregateLoader.coerce_aggregators()
                • AggregateLoader.default
                • AggregateLoader.normalize()
              • AggregateEvluationConfig
                • AggregateEvluationConfig.coerce_aggregators()
                • AggregateEvluationConfig.default
                • AggregateEvluationConfig.main()
                • AggregateEvluationConfig.normalize()
              • main()
              • run_aggregate()
              • TopResultsReport
              • AggregatorAnalysisMixin
                • AggregatorAnalysisMixin.macro_analysis()
                • AggregatorAnalysisMixin.varied_param_counts()
                • AggregatorAnalysisMixin.dump_varied_parameter_report()
                • AggregatorAnalysisMixin.varied_parameter_report()
                • AggregatorAnalysisMixin.analyze()
                • AggregatorAnalysisMixin.report_best()
                • AggregatorAnalysisMixin.resource_summary_table()
                • AggregatorAnalysisMixin.resource_summary_table_friendly()
                • AggregatorAnalysisMixin.report_resources()
                • AggregatorAnalysisMixin.make_summary_analysis()
                • AggregatorAnalysisMixin.make_result_node_symlinks()
                • AggregatorAnalysisMixin.build_plotter()
                • AggregatorAnalysisMixin.plot_all()
              • Aggregator
                • Aggregator.demo()
                • Aggregator.build()
                • Aggregator.primary_macro_region
                • Aggregator.filterto()
                • Aggregator.compress()
                • Aggregator.metrics
                • Aggregator.resources
                • Aggregator.index
                • Aggregator.requested_params
                • Aggregator.specified_params
                • Aggregator.resolved_params
                • Aggregator.default_vantage_points
                • Aggregator.build_effective_params()
                • Aggregator.find_macro_comparable()
                • Aggregator.gather_macro_compatable_groups()
                • Aggregator.build_macro_tables()
                • Aggregator.build_single_macro_table()
              • inspect_node()
              • aggregate_param_cols()
              • macro_aggregate()
              • hash_param()
              • hash_regions()
              • nan_eq()
            • geowatch.mlops.aggregate_loader module
              • build_tables()
              • load_result_worker()
              • new_process_context_parser()
              • load_result_resolved()
              • out_node_matching_fpaths()
            • geowatch.mlops.aggregate_plots module
              • build_plotter()
              • build_all_param_plots()
              • build_special_columns()
              • preprocess_table_for_seaborn()
              • ParamPlotter
                • ParamPlotter.plot_requested()
                • ParamPlotter.plot_resources()
                • ParamPlotter.plot_overviews()
                • ParamPlotter.plot_params()
                • ParamPlotter.plot_vantage_per_region_overview()
                • ParamPlotter.plot_vantage_macro_overview()
                • ParamPlotter.plot_vantage_params()
              • edit_distance()
              • suggest_did_you_mean()
              • shrink_param_names()
              • SkipPlot
              • Vantage2
                • Vantage2.name
                • Vantage2.metric1
                • Vantage2.metric2
                • Vantage2.scale1
                • Vantage2.scale2
              • Vantage
                • Vantage.metric1
                • Vantage.metric2
                • Vantage.scale1
                • Vantage.scale2
                • Vantage.objective1
                • Vantage.objective2
                • Vantage.name
            • geowatch.mlops.confusor_analysis module
              • ConfusorAnalysisConfig
                • ConfusorAnalysisConfig.default
                • ConfusorAnalysisConfig.normalize()
              • main()
              • ConfusionAnalysis
                • ConfusionAnalysis.reload()
                • ConfusionAnalysis.load_geojson_models()
                • ConfusionAnalysis.load_confusion_assignment()
                • ConfusionAnalysis.load_new_stage_stuff()
                • ConfusionAnalysis.add_confusion_to_geojson_models()
                • ConfusionAnalysis.build_hard_cases()
                • ConfusionAnalysis.dump_confusion_geojson()
                • ConfusionAnalysis.dump_hardneg_geojson()
                • ConfusionAnalysis.dump_hardneg_kwcoco()
                • ConfusionAnalysis.dump_confusion_kwcoco()
                • ConfusionAnalysis.dump_summary_viz()
                • ConfusionAnalysis.dump_site_case_viz()
                • ConfusionAnalysis.build_site_confusion_cases()
              • make_case()
              • visualize_case()
              • make_pred_score_timeline()
              • make_case_timeline()
              • visualize_all_timelines()
              • differentiate_site_id()
              • fix_site_id()
              • coco_upgrade_track_ids()
              • make_summary_visualization()
              • to_styled_kml()
              • nan_to_null()
              • safediv()
            • geowatch.mlops.manager module
              • ManagerConfig
                • ManagerConfig.default
                • ManagerConfig.main()
              • main()
              • DVCExptManager
                • DVCExptManager.summarize()
                • DVCExptManager.list()
                • DVCExptManager.coerce()
                • DVCExptManager.pull_packages()
                • DVCExptManager.gather_packages()
                • DVCExptManager.add_packages()
                • DVCExptManager.repackage_checkpoints()
                • DVCExptManager.push_packages()
                • DVCExptManager.push()
                • DVCExptManager.pull()
                • DVCExptManager.reverse_hash_lookup()
              • ExperimentState
                • ExperimentState.VERSIONED_COLUMNS
                • ExperimentState.STAGING_COLUMNS
                • ExperimentState.staging_rows()
                • ExperimentState.versioned_rows()
                • ExperimentState.staging_table()
                • ExperimentState.versioned_table()
                • ExperimentState.cross_referenced_tables()
                • ExperimentState.list()
                • ExperimentState.summarize()
                • ExperimentState.repackage_checkpoints()
                • ExperimentState.copy_packages_to_dvc()
                • ExperimentState.add_packages_to_dvc()
                • ExperimentState.gather_packages()
                • ExperimentState.add_packages()
                • ExperimentState.push_packages()
              • checkpoint_filepath_info()
              • summarize_tables()
              • UserAbort
            • geowatch.mlops.pipeline_nodes module
              • Pipeline
                • Pipeline.demo()
                • Pipeline.submit()
                • Pipeline.node_dict
                • Pipeline.build_nx_graphs()
                • Pipeline.inspect_configurables()
                • Pipeline.configure()
                • Pipeline.print_process_graph()
                • Pipeline.print_io_graph()
                • Pipeline.print_commands()
                • Pipeline.print_graphs()
                • Pipeline.submit_jobs()
                • Pipeline.make_queue()
              • bash_printf_literal_string()
              • glob_templated_path()
              • Node
                • Node.connect()
                • Node.key
              • IONode
                • IONode.final_value
                • IONode.key
              • InputNode
              • OutputNode
                • OutputNode.final_value
                • OutputNode.template_value
                • OutputNode.matching_fpaths()
              • memoize_configured_method
              • memoize_configured_property()
              • ProcessNode
                • ProcessNode.name
                • ProcessNode.executable
                • ProcessNode.algo_params
                • ProcessNode.perf_params
                • ProcessNode.in_paths
                • ProcessNode.out_paths
                • ProcessNode.primary_out_key
                • ProcessNode.group_dname
                • ProcessNode.configure()
                • ProcessNode.condensed
                • ProcessNode.final_config
                • ProcessNode.final_perf_config
                • ProcessNode.final_algo_config
                • ProcessNode.final_in_paths
                • ProcessNode.template_out_paths
                • ProcessNode.final_out_paths
                • ProcessNode.final_node_dpath
                • ProcessNode.final_root_dpath
                • ProcessNode.template_group_dpath
                • ProcessNode.template_node_dpath
                • ProcessNode.template_root_dpath
                • ProcessNode.predecessor_process_nodes()
                • ProcessNode.successor_process_nodes()
                • ProcessNode.ancestor_process_nodes()
                • ProcessNode.depends
                • ProcessNode.algo_id
                • ProcessNode.process_id
                • ProcessNode.inputs
                • ProcessNode.outputs
                • ProcessNode.command
                • ProcessNode.test_is_computed_command()
                • ProcessNode.does_exist
                • ProcessNode.outputs_exist
                • ProcessNode.final_command()
                • ProcessNode.find_template_outputs()
              • demodata_pipeline()
              • demo_pipeline_run()
              • PipelineDAG
              • coerce_pipeline()
            • geowatch.mlops.repackager module
              • RepackageConfig
                • RepackageConfig.default
                • RepackageConfig.main()
              • main()
              • repackage()
              • looks_like_training_directory()
              • inspect_checkpoint_context()
              • suggest_package_name_for_checkpoint()
              • parse_and_init_config()
              • torch_load_cpu()
              • repackage_single_checkpoint()
              • load_meta()
            • geowatch.mlops.schedule_evaluation module
              • ScheduleEvaluationConfig
                • ScheduleEvaluationConfig.default
                • ScheduleEvaluationConfig.main()
                • ScheduleEvaluationConfig.normalize()
              • main()
              • schedule_evaluation()
              • ensure_iterable()
            • geowatch.mlops.smart_global_helper module
              • SmartGlobalHelper
                • SmartGlobalHelper.TARGET_METRICS
                • SmartGlobalHelper.VIZ_BLOCKLIST
                • SmartGlobalHelper.EXTRA_HASHID_IGNORE_COLUMNS
                • SmartGlobalHelper.EXTRA_PATH_COLUMNS
                • SmartGlobalHelper.LABEL_MAPPINGS
                • SmartGlobalHelper.shared_palettes()
                • SmartGlobalHelper.make_param_palette()
                • SmartGlobalHelper.region_palette()
                • SmartGlobalHelper.label_modifier()
                • SmartGlobalHelper.default_vantage_points()
                • SmartGlobalHelper.mark_star_models()
                • SmartGlobalHelper.mark_delivery()
                • SmartGlobalHelper.populate_test_dataset_bundles()
                • SmartGlobalHelper.get_delivered_model_params()
                • SmartGlobalHelper.custom_channel_relabel()
                • SmartGlobalHelper.custom_channel_relabel_mapping()
                • SmartGlobalHelper.print_minmax_times()
                • SmartGlobalHelper.threshold_param_groups()
            • geowatch.mlops.smart_pipeline module
              • FeatureComputation
                • FeatureComputation.executable
                • FeatureComputation.group_dname
                • FeatureComputation.in_paths
                • FeatureComputation.command()
                • FeatureComputation.condensed
              • FeatureUnion
                • FeatureUnion.name
                • FeatureUnion.executable
                • FeatureUnion.group_dname
                • FeatureUnion.in_paths
                • FeatureUnion.out_paths
                • FeatureUnion.command()
              • HeatmapPrediction
                • HeatmapPrediction.executable
                • HeatmapPrediction.group_dname
                • HeatmapPrediction.perf_params
                • HeatmapPrediction.in_paths
                • HeatmapPrediction.algo_params
                • HeatmapPrediction.out_paths
                • HeatmapPrediction.command()
              • PolygonPrediction
                • PolygonPrediction.executable
                • PolygonPrediction.group_dname
                • PolygonPrediction.default_track_fn
                • PolygonPrediction.in_paths
                • PolygonPrediction.out_paths
                • PolygonPrediction.command()
              • PolygonEvaluation
                • PolygonEvaluation.executable
                • PolygonEvaluation.group_dname
                • PolygonEvaluation.in_paths
                • PolygonEvaluation.out_paths
                • PolygonEvaluation.perf_params
                • PolygonEvaluation.command()
              • HeatmapEvaluation
                • HeatmapEvaluation.executable
                • HeatmapEvaluation.group_dname
                • HeatmapEvaluation.in_paths
                • HeatmapEvaluation.out_paths
                • HeatmapEvaluation.command()
              • KWCocoVisualization
                • KWCocoVisualization.executable
                • KWCocoVisualization.group_dname
                • KWCocoVisualization.in_paths
                • KWCocoVisualization.out_paths
                • KWCocoVisualization.command()
              • InvariantFeatureComputation
                • InvariantFeatureComputation.name
                • InvariantFeatureComputation.out_paths
              • MaterialFeatureComputation
                • MaterialFeatureComputation.name
                • MaterialFeatureComputation.out_paths
              • LandcoverFeatureComputation
                • LandcoverFeatureComputation.name
                • LandcoverFeatureComputation.out_paths
              • BAS_HeatmapPrediction
                • BAS_HeatmapPrediction.name
                • BAS_HeatmapPrediction.algo_params
                • BAS_HeatmapPrediction.condensed
              • SC_HeatmapPrediction
                • SC_HeatmapPrediction.name
                • SC_HeatmapPrediction.algo_params
                • SC_HeatmapPrediction.condensed
              • BAS_PolygonPrediction
                • BAS_PolygonPrediction.name
                • BAS_PolygonPrediction.default_track_fn
                • BAS_PolygonPrediction.final_algo_config
              • SC_PolygonPrediction
                • SC_PolygonPrediction.name
                • SC_PolygonPrediction.default_track_fn
                • SC_PolygonPrediction.final_algo_config
              • BAS_HeatmapEvaluation
                • BAS_HeatmapEvaluation.name
              • SC_HeatmapEvaluation
                • SC_HeatmapEvaluation.name
              • BAS_PolygonEvaluation
                • BAS_PolygonEvaluation.name
              • SC_PolygonEvaluation
                • SC_PolygonEvaluation.name
              • BAS_Visualization
                • BAS_Visualization.name
              • SC_Visualization
                • SC_Visualization.name
              • Cropping
                • Cropping.executable
                • Cropping.group_dname
                • Cropping.algo_params
                • Cropping.perf_params
                • Cropping.in_paths
                • Cropping.condensed
                • Cropping.command()
              • SiteClustering
                • SiteClustering.executable
                • SiteClustering.name
                • SiteClustering.group_dname
                • SiteClustering.algo_params
                • SiteClustering.perf_params
                • SiteClustering.in_paths
                • SiteClustering.out_paths
              • SC_Cropping
                • SC_Cropping.name
                • SC_Cropping.group_dname
                • SC_Cropping.algo_params
                • SC_Cropping.out_paths
              • SV_Cropping
                • SV_Cropping.name
                • SV_Cropping.algo_params
                • SV_Cropping.out_paths
              • SV_DepthPredict
                • SV_DepthPredict.name
                • SV_DepthPredict.executable
                • SV_DepthPredict.group_dname
                • SV_DepthPredict.in_paths
                • SV_DepthPredict.out_paths
                • SV_DepthPredict.algo_params
                • SV_DepthPredict.command()
              • SV_DepthFilter
                • SV_DepthFilter.name
                • SV_DepthFilter.executable
                • SV_DepthFilter.group_dname
                • SV_DepthFilter.in_paths
                • SV_DepthFilter.out_paths
                • SV_DepthFilter.algo_params
                • SV_DepthFilter.command()
              • DinoBoxDetector
                • DinoBoxDetector.name
                • DinoBoxDetector.executable
                • DinoBoxDetector.group_dname
                • DinoBoxDetector.in_paths
                • DinoBoxDetector.out_paths
                • DinoBoxDetector.algo_params
                • DinoBoxDetector.perf_params
                • DinoBoxDetector.command()
              • SV_DinoFilter
                • SV_DinoFilter.name
                • SV_DinoFilter.executable
                • SV_DinoFilter.group_dname
                • SV_DinoFilter.in_paths
                • SV_DinoFilter.out_paths
                • SV_DinoFilter.algo_params
                • SV_DinoFilter.command()
              • bas_nodes()
              • sc_nodes()
              • make_smart_pipeline_nodes()
              • make_smart_pipeline()
              • dzyne_sv_only_pipeline()
            • geowatch.mlops.smart_result_parser module
              • parse_json_header()
              • parse_json_header_cached()
              • trace_json_lineage()
              • load_iarpa_evaluation()
              • load_pxl_eval()
              • Found
              • resolve_cross_machine_path()
              • global_ureg()
              • relevant_pred_pxl_config()
              • parse_resource_item()
              • find_pred_pxl_item()
              • find_info_items()
              • find_track_item()
              • find_metrics_framework_item()
              • find_pxl_eval_item()
          • Module contents
        • geowatch.monkey package
          • Submodules
            • geowatch.monkey.monkey_albumentations module
              • patch_albumentations_for_311()
            • geowatch.monkey.monkey_kwcoco module
              • fix_sorted_set()
            • geowatch.monkey.monkey_kwutil module
              • patch_kwutil_toplevel()
            • geowatch.monkey.monkey_lightning module
              • disable_lightning_hardware_warnings()
            • geowatch.monkey.monkey_numpy module
              • patch_numpy_dtypes()
              • patch_numpy_2x()
            • geowatch.monkey.monkey_pil module
              • fix_pil_version()
            • geowatch.monkey.monkey_scriptconfig module
            • geowatch.monkey.monkey_tensorflow module
              • disable_tensorflow_warnings()
            • geowatch.monkey.monkey_torch module
              • fix_gelu_issue()
              • fix_package_modules()
            • geowatch.monkey.monkey_torchmetrics module
              • fix_torchmetrics_compatability()
          • Module contents
        • geowatch.rc package
          • Subpackages
            • geowatch.rc.requirements package
              • Module contents
          • Submodules
            • geowatch.rc.registry module
              • load_site_model_schema()
              • load_region_model_schema()
              • load_job_schema()
              • geoidgrid_path()
              • dem_path()
              • requirement_path()
          • Module contents
            • dem_path()
            • geoidgrid_path()
            • load_job_schema()
            • load_region_model_schema()
            • load_site_model_schema()
            • requirement_path()
        • geowatch.stac package
          • Submodules
            • geowatch.stac.stac_search_builder module
              • StacSearchBuilderConfig
                • StacSearchBuilderConfig.default
              • print_provider_debug_information()
              • check_processed_regions()
              • build_search_json()
              • main()
            • geowatch.stac.util_stac module
              • parallel_map_items()
              • maps()
              • associate_msi_pan()
          • Module contents
        • geowatch.tasks package
          • Subpackages
            • geowatch.tasks.cold package
              • Submodules
                • geowatch.tasks.cold.assemble_cold_result_kwcoco module
                  • AssembleColdKwcocoConfig
                    • AssembleColdKwcocoConfig.default
                  • assemble_main()
                  • get_gdal_transform()
                  • read_json_metadata()
                • geowatch.tasks.cold.export_change_map module
                • geowatch.tasks.cold.export_cold_result_kwcoco module
                  • ExportColdKwcocoConfig
                    • ExportColdKwcocoConfig.default
                  • export_cold_main()
                  • NoMatchingColdCurve
                  • extract_features()
                  • read_json_metadata()
                • geowatch.tasks.cold.predict module
                  • ColdPredictConfig
                    • ColdPredictConfig.default
                  • cold_predict_main()
                • geowatch.tasks.cold.prepare_ard module
                  • mask_value()
                  • qabitval_array_HLS()
                  • qabitval_array()
                  • qabitval_array_c2()
                  • load_data()
                  • single_image_stacking_hls()
                  • single_image_stacking_hls14()
                  • single_image_stacking()
                  • single_image_stacking_collection2()
                  • checkfinished_step1()
                  • checkfinished_step2()
                  • checkfinished_step3_partition()
                  • checkfinished_step3_nopartition()
                  • get_extent()
                  • get_feature()
                  • explode()
                  • bbox()
                • geowatch.tasks.cold.prepare_kwcoco module
                  • PrepareKwcocoConfig
                    • PrepareKwcocoConfig.default
                  • prepare_kwcoco_main()
                  • qa_decoding()
                  • qa_decoding_no_boundary()
                  • setup_logging()
                  • hist_cut()
                  • minmax_norm()
                  • artificial_surface_index()
                  • stack_kwcoco()
                  • stack_kwcoco_PD()
                  • process_one_coco_image()
                • geowatch.tasks.cold.tile_processing module
                  • tileprocessing_report()
                  • reading_start_dates_nmaps()
                  • is_finished_cold_blockfinished()
                  • is_finished_assemble_cmmaps()
                  • get_stack_date()
                • geowatch.tasks.cold.tile_processing_kwcoco module
                  • TileProcessingKwcocoConfig
                    • TileProcessingKwcocoConfig.default
                  • tile_process_main()
                  • read_json_metadata()
                  • is_finished_cold_blockfinished()
                  • get_stack_date()
                  • reading_start_dates_nmaps()
                  • is_finished_assemble_cmmaps()
                • geowatch.tasks.cold.transfer_features module
                  • TransferCocoConfig
                    • TransferCocoConfig.default
                  • transfer_features_main()
                • geowatch.tasks.cold.writing_kwcoco module
                  • WriteColdCocoConfig
                    • WriteColdCocoConfig.default
                  • cold_writing_kwcoco_main()
                  • read_json_metadata()
              • Module contents
            • geowatch.tasks.depth package
              • Submodules
                • geowatch.tasks.depth.backbone module
                  • get_backbone()
                  • set_download_dir()
                • geowatch.tasks.depth.datasets module
                  • WVRgbDataset
                  • WVSuperRgbDataset
                • geowatch.tasks.depth.demo_transform module
                  • Scale
                    • Scale.changeScale()
                  • CenterCrop
                    • CenterCrop.centerCrop()
                  • ToTensor
                    • ToTensor.to_tensor()
                  • ToNumpy
                    • ToNumpy.to_numpy()
                  • Normalize
                    • Normalize.normalize()
                  • Lighting
                • geowatch.tasks.depth.dzyne_img_util module
                  • pad()
                  • unpad()
                  • minmax()
                  • equalizeRGB()
                  • normalizeRGB()
                  • load_image()
                  • readRasterImage()
                • geowatch.tasks.depth.pl_highres_verify module
                  • modify_bn()
                  • MultiTaskModel
                    • MultiTaskModel.forward()
                    • MultiTaskModel.test_step()
                    • MultiTaskModel.add_model_specific_args()
                  • anisotropic_diffusion()
                • geowatch.tasks.depth.predict module
                  • fake_model()
                  • run_inference()
                • geowatch.tasks.depth.utils module
                  • process_image_chunked()
              • Module contents
            • geowatch.tasks.depth_pcd package
              • Submodules
                • geowatch.tasks.depth_pcd.filter_tracks module
                  • FilterTracksConfig
                    • FilterTracksConfig.default
                  • main()
                • geowatch.tasks.depth_pcd.model module
                • geowatch.tasks.depth_pcd.model_test module
                  • mwe_tensorflow()
                • geowatch.tasks.depth_pcd.score_tracks module
                  • ScoreTracksConfig
                    • ScoreTracksConfig.default
                  • score_tracks()
                  • main()
              • Module contents
            • geowatch.tasks.dino_detector package
              • Submodules
                • geowatch.tasks.dino_detector.building_validator module
                  • BuildingValidatorConfig
                    • BuildingValidatorConfig.default
                  • main()
                  • make_decisions()
                  • building_in_image_features()
                  • CouldNotValidate
                • geowatch.tasks.dino_detector.predict module
                  • BuildingDetectorConfig
                    • BuildingDetectorConfig.default
                  • WrapperDataset
                  • main()
                  • dino_preproc_item()
                  • dino_predict()
              • Module contents
            • geowatch.tasks.fusion package
              • Subpackages
                • geowatch.tasks.fusion.architectures package
                  • Submodules
                    • geowatch.tasks.fusion.architectures.segmenter_decoder module
                      • trunc_normal_()
                      • drop_path()
                      • DropPath
                        • DropPath.forward()
                      • init_weights()
                      • FeedForward
                        • FeedForward.unwrapped
                        • FeedForward.forward()
                      • Attention
                        • Attention.unwrapped
                        • Attention.forward()
                      • Block
                        • Block.forward()
                      • DecoderLinear
                        • DecoderLinear.no_weight_decay()
                        • DecoderLinear.forward()
                      • MaskTransformerDecoder
                        • MaskTransformerDecoder.no_weight_decay()
                        • MaskTransformerDecoder.forward()
                        • MaskTransformerDecoder.get_attention_map()
                    • geowatch.tasks.fusion.architectures.sits module
                      • PositionalEncoding
                        • PositionalEncoding.forward()
                      • BERTEmbedding
                        • BERTEmbedding.forward()
                      • BERT
                        • BERT.forward()
                      • MulticlassClassification
                        • MulticlassClassification.forward()
                      • BERTClassification
                        • BERTClassification.forward()
                    • geowatch.tasks.fusion.architectures.transformer module
                      • ResidualSequential
                        • ResidualSequential.forward()
                      • ResidualAttentionSequential
                        • ResidualAttentionSequential.forward()
                      • assert_allclose()
                      • MultiheadSelfAttention
                        • MultiheadSelfAttention.forward()
                      • MetaModuleProperties
                      • ModuleProperties
                        • ModuleProperties.getattr()
                      • new_attention_layer()
                      • new_mlp_layer()
                      • ChannelwiseTransformerEncoderLayer
                        • ChannelwiseTransformerEncoderLayer.forward()
                      • TimmEncoder
                      • MM_VITEncoder
                        • MM_VITEncoder.initialize_from_pretrained()
                        • MM_VITEncoder.forward()
                      • DeiTEncoder
                        • DeiTEncoder.forward()
                      • PerceiverEncoder
                        • PerceiverEncoder.forward()
                      • FusionEncoder
                        • FusionEncoder.forward()
                      • default()
                      • cache_fn()
                      • PreNorm
                        • PreNorm.forward()
                      • GEGLU
                        • GEGLU.forward()
                      • FeedForward
                        • FeedForward.forward()
                      • Attention
                        • Attention.forward()
                      • BackboneEncoderDecoder
                      • TransformerEncoderDecoder
                        • TransformerEncoderDecoder.forward()
                      • TransformerEncoderLayerExtended
                      • VanillaTransformerEncoder
                        • VanillaTransformerEncoder.forward()
                      • MM_VITEncoderDecoder
                        • MM_VITEncoderDecoder.pretrained_fpath_shortnames
                        • MM_VITEncoderDecoder.initialize_from_pretrained()
                        • MM_VITEncoderDecoder.forward()
                    • geowatch.tasks.fusion.architectures.unet_blur module
                      • BlurPool
                        • BlurPool.forward()
                      • get_pad_layer()
                      • double_conv
                        • double_conv.forward()
                      • inconv
                        • inconv.forward()
                      • down
                        • down.forward()
                      • up
                        • up.forward()
                      • outconv
                        • outconv.forward()
                      • UNet
                        • UNet.forward()
                    • geowatch.tasks.fusion.architectures.wu_mae module
                      • PreNorm
                        • PreNorm.forward()
                      • FeedForward
                        • FeedForward.forward()
                      • Attention
                        • Attention.forward()
                      • pair()
                      • Transformer
                        • Transformer.forward()
                      • ViT
                        • ViT.forward()
                      • wu_backbone()
                  • Module contents
                • geowatch.tasks.fusion.datamodules package
                  • Subpackages
                    • geowatch.tasks.fusion.datamodules.temporal_sampling package
                      • Submodules
                        • geowatch.tasks.fusion.datamodules.temporal_sampling.affinity module
                          • affinity_sample()
                          • make_soft_mask()
                          • hard_time_sample_pattern()
                          • soft_frame_affinity()
                          • hard_frame_affinity()
                          • cython_aff_samp_mod()
                        • geowatch.tasks.fusion.datamodules.temporal_sampling.affinity_sampling module
                        • geowatch.tasks.fusion.datamodules.temporal_sampling.exceptions module
                          • TimeSampleError
                        • geowatch.tasks.fusion.datamodules.temporal_sampling.plots module
                          • show_affinity_sample_process()
                          • plot_dense_sample_indices()
                          • plot_temporal_sample_indices()
                          • plot_temporal_sample()
                        • geowatch.tasks.fusion.datamodules.temporal_sampling.sampler module
                          • CommonSamplerMixin
                            • CommonSamplerMixin.from_coco_video()
                            • CommonSamplerMixin.from_datetimes()
                          • MultiTimeWindowSampler
                            • MultiTimeWindowSampler.sample()
                            • MultiTimeWindowSampler.affinity
                            • MultiTimeWindowSampler.show_summary()
                          • TimeWindowSampler
                            • TimeWindowSampler.update_affinity()
                            • TimeWindowSampler.compute_affinity()
                            • TimeWindowSampler.main_indexes
                            • TimeWindowSampler.sample()
                            • TimeWindowSampler.show_summary()
                            • TimeWindowSampler.show_affinity()
                            • TimeWindowSampler.show_procedure()
                        • geowatch.tasks.fusion.datamodules.temporal_sampling.time_kernel module
                          • TimeKernel
                            • TimeKernel.coerce()
                            • TimeKernel.coerce_multiple()
                            • TimeKernel.make_soft_mask()
                            • TimeKernel.plot()
                        • geowatch.tasks.fusion.datamodules.temporal_sampling.time_kernel_grammar module
                          • MultiTimeKernelTransformer
                            • MultiTimeKernelTransformer.bare_kernel()
                            • MultiTimeKernelTransformer.paren_kernel()
                            • MultiTimeKernelTransformer.multi_kernel()
                          • parse_multi_time_kernel()
                        • geowatch.tasks.fusion.datamodules.temporal_sampling.utils module
                          • guess_missing_unixtimes()
                          • coerce_time_kernel()
                          • coerce_multi_time_kernel()
                      • Module contents
                        • CommonSamplerMixin
                          • CommonSamplerMixin.from_coco_video()
                          • CommonSamplerMixin.from_datetimes()
                        • MultiTimeWindowSampler
                          • MultiTimeWindowSampler.affinity
                          • MultiTimeWindowSampler.sample()
                          • MultiTimeWindowSampler.show_summary()
                        • TimeSampleError
                        • TimeWindowSampler
                          • TimeWindowSampler.compute_affinity()
                          • TimeWindowSampler.main_indexes
                          • TimeWindowSampler.sample()
                          • TimeWindowSampler.show_affinity()
                          • TimeWindowSampler.show_procedure()
                          • TimeWindowSampler.show_summary()
                          • TimeWindowSampler.update_affinity()
                        • affinity_sample()
                        • cython_aff_samp_mod()
                        • guess_missing_unixtimes()
                        • hard_frame_affinity()
                        • hard_time_sample_pattern()
                        • plot_dense_sample_indices()
                        • plot_temporal_sample()
                        • plot_temporal_sample_indices()
                        • show_affinity_sample_process()
                        • soft_frame_affinity()
                  • Submodules
                    • geowatch.tasks.fusion.datamodules.batch_visualization module
                      • BatchVisualizationBuilder
                        • BatchVisualizationBuilder.populate_demo_output()
                        • BatchVisualizationBuilder.build()
                      • colorize_weights()
                    • geowatch.tasks.fusion.datamodules.data_augment module
                      • SpacetimeAugmentMixin
                    • geowatch.tasks.fusion.datamodules.data_utils module
                      • resolve_scale_request()
                      • abslog_scaling()
                      • fliprot()
                      • fliprot_annot()
                      • inv_fliprot_annot()
                      • inv_fliprot()
                      • samecolor_nodata_mask()
                      • MultiscaleMask
                        • MultiscaleMask.update()
                        • MultiscaleMask.apply()
                        • MultiscaleMask.masked_fraction
                    • geowatch.tasks.fusion.datamodules.kwcoco_datamodule module
                      • KWCocoVideoDataModuleConfig
                        • KWCocoVideoDataModuleConfig.default
                      • KWCocoVideoDataModule
                        • KWCocoVideoDataModule.setup()
                        • KWCocoVideoDataModule.train_dataset
                        • KWCocoVideoDataModule.test_dataset
                        • KWCocoVideoDataModule.vali_dataset
                        • KWCocoVideoDataModule.add_argparse_args()
                        • KWCocoVideoDataModule.compatible()
                        • KWCocoVideoDataModule.draw_batch()
                    • geowatch.tasks.fusion.datamodules.kwcoco_dataset module
                      • Known Issues
                      • Roadmap
                      • KWCocoVideoDatasetConfig
                        • KWCocoVideoDatasetConfig.default
                        • KWCocoVideoDatasetConfig.normalize()
                      • TruthMixin
                      • GetItemMixin
                        • GetItemMixin.getitem()
                      • IntrospectMixin
                        • IntrospectMixin.draw_item()
                        • IntrospectMixin.summarize_item()
                      • BalanceMixin
                      • PreprocessMixin
                        • PreprocessMixin.cached_dataset_stats()
                        • PreprocessMixin.compute_dataset_stats()
                      • MiscMixin
                        • MiscMixin.reseed()
                        • MiscMixin.coco_dset
                        • MiscMixin.make_loader()
                      • BackwardCompatMixin
                        • BackwardCompatMixin.new_sample_grid
                      • KWCocoVideoDataset
                      • more_demos()
                      • worker_init_fn()
                      • FailedSample
                      • Modality
                        • Modality.sensor
                        • Modality.channels
                        • Modality.domain
                      • Domain
                        • Domain.sensor
                        • Domain.channels
                        • Domain.video_name
                    • geowatch.tasks.fusion.datamodules.kwcoco_video_data module
                    • geowatch.tasks.fusion.datamodules.network_io module
                      • BatchItem
                        • BatchItem.asdict()
                        • BatchItem.draw()
                        • BatchItem.demo()
                        • BatchItem.summarize()
                      • HeterogeneousBatchItem
                        • HeterogeneousBatchItem.num_frames
                        • HeterogeneousBatchItem.sensorchan_histogram
                        • HeterogeneousBatchItem.demo()
                        • HeterogeneousBatchItem.draw()
                        • HeterogeneousBatchItem.summarize()
                      • HomogeneousBatchItem
                        • HomogeneousBatchItem.demo()
                      • RGBImageBatchItem
                        • RGBImageBatchItem.frame
                        • RGBImageBatchItem.channels
                        • RGBImageBatchItem.imdata_chw
                        • RGBImageBatchItem.nonlocal_class_ohe
                        • RGBImageBatchItem.demo()
                      • UncollatedBatch
                      • HeterogeneousBatch
                      • UncollatedRGBImageBatch
                        • UncollatedRGBImageBatch.demo()
                        • UncollatedRGBImageBatch.coerce()
                        • UncollatedRGBImageBatch.from_items()
                        • UncollatedRGBImageBatch.collate()
                      • CollatedBatch
                        • CollatedBatch.asdict()
                      • CollatedRGBImageBatch
                        • CollatedRGBImageBatch.to()
                      • NetworkOutputs
                      • UncollatedNetworkOutputs
                      • CollatedNetworkOutputs
                        • CollatedNetworkOutputs.decollate()
                      • decollate()
                    • geowatch.tasks.fusion.datamodules.qa_bands module
                      • QA_SpecMixin
                        • QA_SpecMixin.draw_labels()
                      • QA_BitSpecTable
                        • QA_BitSpecTable.mask_any()
                        • QA_BitSpecTable.describe_values()
                      • unpack_bit_positions()
                      • QA_ValueSpecTable
                        • QA_ValueSpecTable.mask_any()
                        • QA_ValueSpecTable.describe_values()
                      • QA_SpecRegistry
                        • QA_SpecRegistry.query_table()
                        • QA_SpecRegistry.find_table()
                      • demo()
                    • geowatch.tasks.fusion.datamodules.smart_mixins module
                      • SMARTDataMixin
                        • SMARTDataMixin.check_balanced_sample_tree()
                      • draw_cloudmask_viz()
                    • geowatch.tasks.fusion.datamodules.spacetime_grid_builder module
                      • SpacetimeGridBuilder
                        • SpacetimeGridBuilder.build()
                        • SpacetimeGridBuilder.visualize()
                      • ImagePropertyCacher
                        • ImagePropertyCacher.get_warp_vid_from_img()
                        • ImagePropertyCacher.get_image_valid_region_in_vidspace()
                      • sample_video_spacetime_targets()
                  • Module contents
                    • KWCocoVideoDataModule
                      • KWCocoVideoDataModule.add_argparse_args()
                      • KWCocoVideoDataModule.compatible()
                      • KWCocoVideoDataModule.draw_batch()
                      • KWCocoVideoDataModule.setup()
                      • KWCocoVideoDataModule.test_dataset
                      • KWCocoVideoDataModule.train_dataset
                      • KWCocoVideoDataModule.vali_dataset
                    • KWCocoVideoDataset
                • geowatch.tasks.fusion.methods package
                  • Submodules
                    • geowatch.tasks.fusion.methods.channelwise_transformer module
                      • MultimodalTransformerConfig
                        • MultimodalTransformerConfig.default
                        • MultimodalTransformerConfig.normalize()
                      • MultimodalTransformer
                        • MultimodalTransformer.add_argparse_args()
                        • MultimodalTransformer.compatible()
                        • MultimodalTransformer.configure_optimizers()
                        • MultimodalTransformer.overfit()
                        • MultimodalTransformer.prepare_item()
                        • MultimodalTransformer.forward_step()
                        • MultimodalTransformer.forward_item()
                        • MultimodalTransformer.forward_foot()
                        • MultimodalTransformer.training_step()
                        • MultimodalTransformer.optimizer_step()
                        • MultimodalTransformer.parameter_hacking()
                        • MultimodalTransformer.validation_step()
                        • MultimodalTransformer.test_step()
                        • MultimodalTransformer.save_package()
                        • MultimodalTransformer.forward()
                        • MultimodalTransformer.get_cfgstr()
                      • slice_to_agree()
                      • perterb_params()
                    • geowatch.tasks.fusion.methods.efficientdet module
                      • normal_init()
                      • bias_init_with_prob()
                      • conv_ws_2d()
                      • ConvWS2d
                        • ConvWS2d.forward()
                      • build_norm_layer()
                      • build_conv_layer()
                      • ConvModule
                        • ConvModule.norm
                        • ConvModule.forward()
                      • multi_apply()
                      • RetinaHead
                        • RetinaHead.init_weights()
                        • RetinaHead.forward_single()
                        • RetinaHead.forward()
                      • calc_iou()
                      • FocalLoss
                        • FocalLoss.forward()
                      • drop_connect()
                      • round_repeats()
                      • round_filters()
                      • load_pretrained_weights()
                      • Identity
                        • Identity.forward()
                      • Conv2dStaticSamePadding
                        • Conv2dStaticSamePadding.forward()
                      • Conv2dDynamicSamePadding
                        • Conv2dDynamicSamePadding.forward()
                      • get_same_padding_conv2d()
                      • BlockArgs
                        • BlockArgs.expand_ratio
                        • BlockArgs.id_skip
                        • BlockArgs.input_filters
                        • BlockArgs.kernel_size
                        • BlockArgs.num_repeat
                        • BlockArgs.output_filters
                        • BlockArgs.se_ratio
                        • BlockArgs.stride
                      • GlobalParams
                        • GlobalParams.batch_norm_epsilon
                        • GlobalParams.batch_norm_momentum
                        • GlobalParams.depth_coefficient
                        • GlobalParams.depth_divisor
                        • GlobalParams.drop_connect_rate
                        • GlobalParams.dropout_rate
                        • GlobalParams.image_size
                        • GlobalParams.min_depth
                        • GlobalParams.num_classes
                        • GlobalParams.width_coefficient
                      • BlockDecoder
                        • BlockDecoder.decode()
                        • BlockDecoder.encode()
                      • efficientnet_params()
                      • efficientnet()
                      • get_model_params()
                      • Swish
                        • Swish.forward()
                      • SwishImplementation
                        • SwishImplementation.forward()
                        • SwishImplementation.backward()
                      • MemoryEfficientSwish
                        • MemoryEfficientSwish.forward()
                      • MBConvBlock
                        • MBConvBlock.forward()
                        • MBConvBlock.set_swish()
                      • EfficientNet
                        • EfficientNet.set_swish()
                        • EfficientNet.extract_features()
                        • EfficientNet.forward()
                        • EfficientNet.from_name()
                        • EfficientNet.from_pretrained()
                        • EfficientNet.get_image_size()
                        • EfficientNet.get_list_features()
                      • ClipBoxes
                        • ClipBoxes.forward()
                      • xavier_init()
                      • BiFPNModule
                        • BiFPNModule.init_weights()
                        • BiFPNModule.forward()
                      • BIFPN
                        • BIFPN.init_weights()
                        • BIFPN.forward()
                      • BBoxTransform
                        • BBoxTransform.forward()
                      • shift()
                      • generate_anchors()
                      • Anchors
                        • Anchors.forward()
                      • EfficientDetCoder
                        • EfficientDetCoder.decode_batch()
                      • EfficientDet
                        • EfficientDet.forward()
                        • EfficientDet.freeze_bn()
                        • EfficientDet.train()
                        • EfficientDet.extract_feat()
                    • geowatch.tasks.fusion.methods.heads module
                      • TaskHeads
                        • TaskHeads.forward()
                        • TaskHeads.compute_loss()
                    • geowatch.tasks.fusion.methods.heterogeneous module
                      • to_next_multiple()
                      • positions_from_shape()
                      • PadToMultiple
                        • PadToMultiple.forward()
                      • NanToNum
                        • NanToNum.forward()
                      • ShapePreservingTransformerEncoder
                        • ShapePreservingTransformerEncoder.forward()
                      • ScaleAwarePositionalEncoder
                        • ScaleAwarePositionalEncoder.forward()
                      • MipNerfPositionalEncoder
                        • MipNerfPositionalEncoder.forward()
                      • ScaleAgnostictPositionalEncoder
                        • ScaleAgnostictPositionalEncoder.forward()
                      • ResNetShim
                        • ResNetShim.forward()
                      • HeterogeneousModel
                        • HeterogeneousModel.get_cfgstr()
                        • HeterogeneousModel.process_input_tokens()
                        • HeterogeneousModel.process_query_tokens()
                        • HeterogeneousModel.forward()
                        • HeterogeneousModel.shared_step()
                        • HeterogeneousModel.training_step()
                        • HeterogeneousModel.validation_step()
                        • HeterogeneousModel.test_step()
                        • HeterogeneousModel.predict_step()
                        • HeterogeneousModel.forward_step()
                        • HeterogeneousModel.log_grad_norm()
                        • HeterogeneousModel.save_package()
                        • HeterogeneousModel.configure_optimizers()
                    • geowatch.tasks.fusion.methods.loss module
                      • coerce_criterion()
                    • geowatch.tasks.fusion.methods.network_modules module
                      • drop_path()
                      • RobustModuleDict
                        • RobustModuleDict.repl_dot
                        • RobustModuleDict.repl_empty
                        • RobustModuleDict.pop()
                      • RobustParameterDict
                        • RobustParameterDict.repl_dot
                        • RobustParameterDict.repl_empty
                        • RobustParameterDict.pop()
                      • OurDepthwiseSeparableConv
                        • OurDepthwiseSeparableConv.feature_info()
                        • OurDepthwiseSeparableConv.forward()
                      • DWCNNTokenizer
                      • LinearConvTokenizer
                      • ConvTokenizer
                        • ConvTokenizer.forward()
                      • RearrangeTokenizer
                        • RearrangeTokenizer.forward()
                      • torch_safe_stack()
                    • geowatch.tasks.fusion.methods.noop_model module
                      • NoopModel
                        • NoopModel.get_cfgstr()
                        • NoopModel.forward()
                        • NoopModel.shared_step()
                        • NoopModel.training_step()
                        • NoopModel.forward_step()
                        • NoopModel.configure_optimizers()
                        • NoopModel.save_package()
                    • geowatch.tasks.fusion.methods.object_head module
                      • DetrDecoderForObjectDetection
                        • DetrDecoderForObjectDetection.forward()
                    • geowatch.tasks.fusion.methods.torchvision_nets module
                      • TorchvisionWrapper
                        • TorchvisionWrapper.define_ots_model()
                        • TorchvisionWrapper.forward()
                        • TorchvisionWrapper.collate()
                      • TorchvisionSegmentationWrapper
                      • TorchvisionClassificationWrapper
                      • TorchvisionDetectionWrapper
                      • EfficientNetB7
                        • EfficientNetB7.define_ots_model()
                      • FCNResNet50
                        • FCNResNet50.define_ots_model()
                        • FCNResNet50.forward()
                        • FCNResNet50.save_package()
                        • FCNResNet50.forward_step()
                      • Resnet50
                        • Resnet50.forward()
                        • Resnet50.forward_step()
                        • Resnet50.define_ots_model()
                        • Resnet50.training_step()
                        • Resnet50.on_before_batch_transfer()
                    • geowatch.tasks.fusion.methods.unet_baseline module
                      • NanToNum
                        • NanToNum.forward()
                      • UNetBaseline
                        • UNetBaseline.get_cfgstr()
                        • UNetBaseline.process_frame()
                        • UNetBaseline.process_example()
                        • UNetBaseline.process_batch()
                        • UNetBaseline.encode_frame()
                        • UNetBaseline.encode_example()
                        • UNetBaseline.encode_batch()
                        • UNetBaseline.forward()
                        • UNetBaseline.shared_step()
                        • UNetBaseline.training_step()
                        • UNetBaseline.validation_step()
                        • UNetBaseline.test_step()
                        • UNetBaseline.predict_step()
                        • UNetBaseline.forward_step()
                        • UNetBaseline.save_package()
                    • geowatch.tasks.fusion.methods.watch_module_mixins module
                      • ExtendTorchMixin
                        • ExtendTorchMixin.reset_weights()
                        • ExtendTorchMixin.devices()
                        • ExtendTorchMixin.main_device
                      • MSIDemoDataMixin
                        • MSIDemoDataMixin.demo_dataset_stats()
                        • MSIDemoDataMixin.demo_batch()
                      • LightningModelMixin
                        • LightningModelMixin.has_trainer
                      • DeprecatedMixin
                        • DeprecatedMixin.configure_optimizers()
                      • OverfitMixin
                        • OverfitMixin.overfit()
                      • PackageMixin
                        • PackageMixin.load_package()
                      • CoerceMixins
                      • DatasetStatsMixin
                        • DatasetStatsMixin.set_dataset_specific_attributes()
                      • WatchModuleMixins
                  • Module contents
                    • MultimodalTransformer
                      • MultimodalTransformer.add_argparse_args()
                      • MultimodalTransformer.compatible()
                      • MultimodalTransformer.configure_optimizers()
                      • MultimodalTransformer.forward()
                      • MultimodalTransformer.forward_foot()
                      • MultimodalTransformer.forward_item()
                      • MultimodalTransformer.forward_step()
                      • MultimodalTransformer.get_cfgstr()
                      • MultimodalTransformer.optimizer_step()
                      • MultimodalTransformer.overfit()
                      • MultimodalTransformer.parameter_hacking()
                      • MultimodalTransformer.prepare_item()
                      • MultimodalTransformer.save_package()
                      • MultimodalTransformer.test_step()
                      • MultimodalTransformer.training_step()
                      • MultimodalTransformer.validation_step()
                    • HeterogeneousModel
                      • HeterogeneousModel.configure_optimizers()
                      • HeterogeneousModel.forward()
                      • HeterogeneousModel.forward_step()
                      • HeterogeneousModel.get_cfgstr()
                      • HeterogeneousModel.log_grad_norm()
                      • HeterogeneousModel.predict_step()
                      • HeterogeneousModel.process_input_tokens()
                      • HeterogeneousModel.process_query_tokens()
                      • HeterogeneousModel.save_package()
                      • HeterogeneousModel.shared_step()
                      • HeterogeneousModel.test_step()
                      • HeterogeneousModel.training_step()
                      • HeterogeneousModel.validation_step()
                    • UNetBaseline
                      • UNetBaseline.encode_batch()
                      • UNetBaseline.encode_example()
                      • UNetBaseline.encode_frame()
                      • UNetBaseline.forward()
                      • UNetBaseline.forward_step()
                      • UNetBaseline.get_cfgstr()
                      • UNetBaseline.predict_step()
                      • UNetBaseline.process_batch()
                      • UNetBaseline.process_example()
                      • UNetBaseline.process_frame()
                      • UNetBaseline.save_package()
                      • UNetBaseline.shared_step()
                      • UNetBaseline.test_step()
                      • UNetBaseline.training_step()
                      • UNetBaseline.validation_step()
                    • NoopModel
                      • NoopModel.configure_optimizers()
                      • NoopModel.forward()
                      • NoopModel.forward_step()
                      • NoopModel.get_cfgstr()
                      • NoopModel.save_package()
                      • NoopModel.shared_step()
                      • NoopModel.training_step()
              • Submodules
                • geowatch.tasks.fusion.coco_stitcher module
                  • demo_coco_stitching_manager()
                  • CocoStitchingManager
                    • CocoStitchingManager.accumulate_image()
                    • CocoStitchingManager.managed_image_ids()
                    • CocoStitchingManager.ready_image_ids()
                    • CocoStitchingManager.submit_finalize_image()
                    • CocoStitchingManager.flush_images()
                    • CocoStitchingManager.seen_image_ids
                    • CocoStitchingManager.finalize_image()
                  • quantize_image()
                  • fix_slice()
                • geowatch.tasks.fusion.evaluate module
                  • SegmentationEvalConfig
                    • SegmentationEvalConfig.default
                  • main()
                  • single_image_segmentation_metrics()
                  • draw_confusion_image()
                  • colorize_class_probs()
                  • draw_truth_borders()
                  • dump_chunked_confusion()
                  • evaluate_segmentations()
                  • MaxQueuePool
                    • MaxQueuePool.submit()
                    • MaxQueuePool.pool_queue_callback()
                    • MaxQueuePool.shutdown()
                • geowatch.tasks.fusion.fit module
                  • coerce_initializer()
                • geowatch.tasks.fusion.fit_lightning module
                  • custom_yaml_load()
                  • custom_yaml_dump()
                  • SmartTrainer
                    • SmartTrainer.log_dpath
                  • TorchGlobals
                    • TorchGlobals.setup()
                  • WeightInitializer
                    • WeightInitializer.setup()
                  • SmartLightningCLI
                    • SmartLightningCLI.configure_optimizers()
                    • SmartLightningCLI.add_arguments_to_parser()
                  • instantiate_datamodule()
                  • make_cli()
                  • main()
                • geowatch.tasks.fusion.fit_registery module
                  • Usage
                  • Registery
                    • Registery.pandas()
                    • Registery.list()
                    • Registery.query()
                  • DictRegistery
                    • DictRegistery.add()
                    • DictRegistery.set()
                    • DictRegistery.remove()
                    • DictRegistery.read()
                  • ListRegistery
                    • ListRegistery.append()
                    • ListRegistery.read()
                    • ListRegistery.pandas()
                  • NewDVCRegistery
                  • FitRegistery
                    • FitRegistery.append()
                    • FitRegistery.peek()
                  • FitRegisteryCLI
                    • FitRegisteryCLI.Append
                      • FitRegisteryCLI.Append.main()
                      • FitRegisteryCLI.Append.default
                    • FitRegisteryCLI.List
                      • FitRegisteryCLI.List.main()
                      • FitRegisteryCLI.List.default
                    • FitRegisteryCLI.Peek
                      • FitRegisteryCLI.Peek.main()
                      • FitRegisteryCLI.Peek.default
                • geowatch.tasks.fusion.helper_scripts module
                  • train_time_helper_scripts()
                • geowatch.tasks.fusion.predict module
                  • DataModuleConfigMixin
                    • DataModuleConfigMixin.default
                  • PredictConfig
                    • PredictConfig.default
                  • build_stitching_managers()
                  • resolve_datamodule()
                  • PeriodicMemoryMonitor
                    • PeriodicMemoryMonitor.check()
                  • predict()
                  • Predictor
                  • main()
                • geowatch.tasks.fusion.production module
                • geowatch.tasks.fusion.utils module
                  • millify()
                  • load_model_from_package()
                  • load_model_header()
                  • Lambda
                    • Lambda.forward()
                  • DimensionDropout
                    • DimensionDropout.forward()
                  • SinePositionalEncoding
                    • SinePositionalEncoding.forward()
                  • model_json()
              • Module contents
            • geowatch.tasks.invariants package
              • Subpackages
                • geowatch.tasks.invariants.late_fusion package
                  • Submodules
                    • geowatch.tasks.invariants.late_fusion.fit_late_fusion module
                      • main()
                    • geowatch.tasks.invariants.late_fusion.pretext_model_late_fusion module
                      • pretext
                        • pretext.TASK_NAMES
                        • pretext.forward()
                        • pretext.shared_step()
                        • pretext.training_step()
                        • pretext.validation_step()
                        • pretext.predict()
                        • pretext.predict_before_after()
                        • pretext.train_dataloader()
                        • pretext.val_dataloader()
                        • pretext.configure_optimizers()
                        • pretext.task_neck()
                        • pretext.pixel_classification_head()
                        • pretext.image_classification_head()
                  • Module contents
              • Submodules
                • geowatch.tasks.invariants.change module
                  • change
                    • change.head()
                    • change.forward()
                    • change.shared_step()
                    • change.training_step()
                    • change.validation_step()
                    • change.validation_epoch_end()
                    • change.run_test()
                    • change.train_dataloader()
                    • change.val_dataloader()
                    • change.configure_optimizers()
                  • main()
                • geowatch.tasks.invariants.fit module
                  • main()
                • geowatch.tasks.invariants.fit_segment module
                  • main()
                • geowatch.tasks.invariants.iarpa_dataset module
                  • kwcoco_dataset
                    • kwcoco_dataset.S2_channel_names
                    • kwcoco_dataset.L8_channel_names
                    • kwcoco_dataset.common_channel_names
                    • kwcoco_dataset.get_img()
                    • kwcoco_dataset.num_channels()
                • geowatch.tasks.invariants.predict module
                  • InvariantPredictConfig
                    • InvariantPredictConfig.default
                    • InvariantPredictConfig.normalize()
                  • Predictor
                    • Predictor.forward()
                  • main()
                • geowatch.tasks.invariants.pretext_model module
                  • pretext
                    • pretext.TASK_NAMES
                    • pretext.forward()
                    • pretext.shared_step()
                    • pretext.training_step()
                    • pretext.validation_step()
                    • pretext.predict()
                    • pretext.train_dataloader()
                    • pretext.val_dataloader()
                    • pretext.configure_optimizers()
                    • pretext.task_neck()
                    • pretext.pixel_classification_head()
                    • pretext.image_classification_head()
                    • pretext.generate_pca_matrix()
                    • pretext.on_save_checkpoint()
                    • pretext.save_package()
                    • pretext.load_package()
                • geowatch.tasks.invariants.segmentation_model module
                  • segmentation_model
                    • segmentation_model.forward()
                    • segmentation_model.shared_step()
                    • segmentation_model.training_step()
                    • segmentation_model.validation_step()
                    • segmentation_model.test_step()
                    • segmentation_model.train_epoch_end()
                    • segmentation_model.validation_epoch_end()
                    • segmentation_model.run_test()
                    • segmentation_model.train_dataloader()
                    • segmentation_model.val_dataloader()
                    • segmentation_model.configure_optimizers()
                    • segmentation_model.save_package()
                    • segmentation_model.load_package()
              • Module contents
            • geowatch.tasks.landcover package
              • Submodules
                • geowatch.tasks.landcover.datasets module
                  • S2Dataset
                  • WVDataset
                  • imresize()
                • geowatch.tasks.landcover.detector module
                  • run()
                  • pad()
                  • predict_image()
                  • normalize()
                  • get_device()
                  • get_model_device()
                  • load_model()
                • geowatch.tasks.landcover.fit module
                • geowatch.tasks.landcover.model_info module
                  • ModelInfo
                    • ModelInfo.create_dataset()
                    • ModelInfo.model_outputs
                    • ModelInfo.load_model()
                  • S2ModelInfo
                    • S2ModelInfo.create_dataset()
                    • S2ModelInfo.model_outputs
                    • S2ModelInfo.load_model()
                  • WVModelInfo
                    • WVModelInfo.create_dataset()
                    • WVModelInfo.model_outputs
                    • WVModelInfo.load_model()
                  • lookup_model_info()
                • geowatch.tasks.landcover.nets module
                  • double_conv()
                  • UNetR
                    • UNetR.forward()
                • geowatch.tasks.landcover.predict module
                  • LandcoverPredictConfig
                    • LandcoverPredictConfig.default
                  • predict()
                  • get_output_file()
              • Module contents
            • geowatch.tasks.mae package
              • Submodules
                • geowatch.tasks.mae.predict module
                  • MAEPredictConfig
                    • MAEPredictConfig.default
                  • WatchDataset
                    • WatchDataset.S2_l2a_channel_names
                    • WatchDataset.S2_channel_names
                    • WatchDataset.L8_channel_names
                    • WatchDataset.update_target_properties()
                  • pair()
                  • PreNorm
                    • PreNorm.forward()
                  • FeedForward
                    • FeedForward.forward()
                  • Attention
                    • Attention.forward()
                  • Transformer
                    • Transformer.forward()
                  • ViT
                    • ViT.forward()
                  • MAE
                    • MAE.forward()
                  • MaeCityscape
                    • MaeCityscape.forward()
                    • MaeCityscape.shared_step()
                  • sigmoid()
                  • Predict
                  • main()
                • geowatch.tasks.mae.predictV2 module
                  • WatchDataset
                    • WatchDataset.S2_l2a_channel_names
                    • WatchDataset.S2_channel_names
                    • WatchDataset.L8_channel_names
                    • WatchDataset.update_target_properties()
                  • MAEPredictConfig
                    • MAEPredictConfig.default
                  • pair()
                  • PreNorm
                    • PreNorm.forward()
                  • FeedForward
                    • FeedForward.forward()
                  • Attention
                    • Attention.forward()
                  • Transformer
                    • Transformer.forward()
                  • ViT
                    • ViT.forward()
                  • MAE
                    • MAE.forward()
                  • MaeCityscape
                    • MaeCityscape.forward()
                    • MaeCityscape.shared_step()
                  • sigmoid()
                  • Predict
                  • main()
                • geowatch.tasks.mae.predictV3 module
                  • WatchDataset
                    • WatchDataset.S2_l2a_channel_names
                    • WatchDataset.S2_channel_names
                    • WatchDataset.L8_channel_names
                    • WatchDataset.update_target_properties()
                  • MAEPredictConfig
                    • MAEPredictConfig.default
                  • pair()
                  • PreNorm
                    • PreNorm.forward()
                  • FeedForward
                    • FeedForward.forward()
                  • Attention
                    • Attention.forward()
                  • Transformer
                    • Transformer.forward()
                  • ViT
                    • ViT.forward()
                  • MAE
                    • MAE.forward()
                  • MaeCityscape
                    • MaeCityscape.forward()
                    • MaeCityscape.shared_step()
                  • sigmoid()
                  • Predict
                  • main()
              • Module contents
            • geowatch.tasks.metrics package
              • Submodules
                • geowatch.tasks.metrics.merge_iarpa_metrics module
                  • RegionResult
                    • RegionResult.region_id
                    • RegionResult.region_model
                    • RegionResult.site_models
                    • RegionResult.bas_dpath
                    • RegionResult.sc_dpath
                    • RegionResult.unbounded_site_status
                    • RegionResult.from_dpath_and_anns_root()
                    • RegionResult.bas_df
                    • RegionResult.site_ids
                    • RegionResult.sc_df
                    • RegionResult.sc_te_df
                    • RegionResult.sc_phasetable
                  • merge_bas_metrics_results()
                  • merge_sc_metrics_results()
                  • merge_metrics_results()
                  • iarpa_bas_color_legend()
                • geowatch.tasks.metrics.viz_sc_results module
                  • viz_sc()
                  • viz_sc_gantt()
                  • viz_sc_multi()
              • Module contents
            • geowatch.tasks.poly_from_point package
              • Submodules
                • geowatch.tasks.poly_from_point.Run_All_SAM module
                  • main()
                • geowatch.tasks.poly_from_point.predict module
                  • PolyFromPointCLI
                    • PolyFromPointCLI.main()
                    • PolyFromPointCLI.default
                  • convert_polygons_to_region_model()
                  • extract_polygons()
                  • image_predicted()
                  • show_mask()
                  • load_sam()
                  • comput_average_boxes()
                  • get_vidspace_info()
                  • load_point_annots()
                  • convert_points_to_poly_with_sam_method()
                • geowatch.tasks.poly_from_point.run_all_pointgen module
                  • RunAllPointgenCLI
                    • RunAllPointgenCLI.default
                  • main()
              • Module contents
            • geowatch.tasks.sam package
              • Submodules
                • geowatch.tasks.sam.predict module
                  • SAMConfig
                    • SAMConfig.default
                  • rgb_from_kwcoco_frame()
                  • SAMWrapperDataset
                  • DenseFeaturePredictor
                    • DenseFeaturePredictor.short_code
                    • DenseFeaturePredictor.chan_code
                    • DenseFeaturePredictor.proc_name
                    • DenseFeaturePredictor.WrapperDsetClass
                    • DenseFeaturePredictor.setup()
                    • DenseFeaturePredictor.run()
                    • DenseFeaturePredictor.predict_batch()
                  • SAMFeaturePredictor
                    • SAMFeaturePredictor.short_code
                    • SAMFeaturePredictor.proc_name
                    • SAMFeaturePredictor.chan_code
                    • SAMFeaturePredictor.WrapperDsetClass
                    • SAMFeaturePredictor.predict_batch()
                  • main()
              • Module contents
            • geowatch.tasks.tracking package
              • Submodules
                • geowatch.tasks.tracking.abstract_classes module
                  • TrackFunction
                    • TrackFunction.forward()
                    • TrackFunction.apply_per_video()
                    • TrackFunction.safe_apply()
                    • TrackFunction.safe_partition()
                    • TrackFunction.safe_union()
                  • NoOpTrackFunction
                    • NoOpTrackFunction.forward()
                  • NewTrackFunction
                    • NewTrackFunction.forward()
                    • NewTrackFunction.create_tracks()
                    • NewTrackFunction.add_tracks_to_dset()
                  • WrappedSingleVideoCocoDataset
                • geowatch.tasks.tracking.agg_functions module
                  • binary()
                  • rescaled_binary()
                  • probs()
                  • rescaled_probs()
                  • mean_normalized()
                  • frequency_weighted_mean()
                • geowatch.tasks.tracking.from_heatmap module
                  • DataFrameFilter
                    • DataFrameFilter.filter_dataframe()
                  • TimePolygonFilter
                    • TimePolygonFilter.filter_dataframe()
                  • TimeSplitFilter
                    • TimeSplitFilter.filter_dataframe()
                  • ResponsePolygonFilter
                    • ResponsePolygonFilter.filter_dataframe()
                  • site_validation()
                  • time_aggregated_polys()
                  • TimeAggregatedPolysConfig
                    • TimeAggregatedPolysConfig.default
                    • TimeAggregatedPolysConfig.normalize()
                  • CommonTrackFn
                    • CommonTrackFn.default
                    • CommonTrackFn.normalize()
                  • TrackFnWithSV
                    • TrackFnWithSV.site_validation
                    • TrackFnWithSV.site_validation_span_steps
                    • TrackFnWithSV.site_validation_thresh
                    • TrackFnWithSV.default
                  • TimeAggregatedBAS
                    • TimeAggregatedBAS.thresh
                    • TimeAggregatedBAS.key
                    • TimeAggregatedBAS.agg_fn
                    • TimeAggregatedBAS.create_tracks()
                    • TimeAggregatedBAS.add_tracks_to_dset()
                    • TimeAggregatedBAS.default
                  • TimeAggregatedSC
                    • TimeAggregatedSC.thresh
                    • TimeAggregatedSC.key
                    • TimeAggregatedSC.bg_key
                    • TimeAggregatedSC.boundaries_as
                    • TimeAggregatedSC.create_tracks()
                    • TimeAggregatedSC.add_tracks_to_dset()
                    • TimeAggregatedSC.default
                  • TimeAggregatedSV
                    • TimeAggregatedSV.thresh
                    • TimeAggregatedSV.key
                    • TimeAggregatedSV.boundaries_as
                    • TimeAggregatedSV.span_steps
                    • TimeAggregatedSV.create_tracks()
                    • TimeAggregatedSV.add_tracks_to_dset()
                    • TimeAggregatedSV.default
                • geowatch.tasks.tracking.from_polygon module
                  • MonoTrack
                    • MonoTrack.forward()
                  • as_shapely_polys()
                  • OverlapTrack
                    • OverlapTrack.min_overlap
                    • OverlapTrack.forward()
                    • OverlapTrack.default
                • geowatch.tasks.tracking.normalize module
                  • dedupe_annots()
                  • remove_small_annots()
                  • ensure_videos()
                  • dedupe_tracks()
                  • shapely_round()
                  • normalize_phases()
                  • dedupe_dates()
                  • run_tracking_pipeline()
                  • normalize()
                • geowatch.tasks.tracking.old_polygon_extraction module
                  • FoundNothing
                  • PolygonExtractConfig
                    • PolygonExtractConfig.default
                  • heatmaps_to_polys()
                • geowatch.tasks.tracking.phase module
                  • viterbi()
                  • class_label_smoothing()
                  • interpolate()
                  • baseline()
                  • sort_by_gid()
                  • ensure_post()
                  • dedupe_background_anns()
                  • current_date()
                  • phase_prediction_baseline()
                • geowatch.tasks.tracking.polygon_extraction module
                  • PolygonExtractor
                    • PolygonExtractor.predict()
                    • PolygonExtractor.predict_polygons()
                    • PolygonExtractor.show()
                    • PolygonExtractor.draw_intermediate()
                    • PolygonExtractor.draw_timesequence()
                    • PolygonExtractor.demo()
                    • PolygonExtractor.demodata()
                  • impute_nans()
                  • impute_nans2()
                  • FeatureCube
                    • FeatureCube.take_channels()
                    • FeatureCube.window_max()
                    • FeatureCube.demo()
                    • FeatureCube.draw()
                  • TimeIntervalSequence
                    • TimeIntervalSequence.apply_grouping()
                    • TimeIntervalSequence.coerce()
                  • TimeInterval
                    • TimeInterval.start
                    • TimeInterval.stop
                    • TimeInterval.coerce()
                    • TimeInterval.closed()
                    • TimeInterval.random()
                  • toydata_demo()
                  • real_data_demo_case_1()
                  • real_data_demo_case_2()
                  • real_data_demo_case_3()
                  • real_data_demo_case_1_fixed()
                  • generate_real_example()
                  • LabelMask
                    • LabelMask.colorize()
                    • LabelMask.resize()
                    • LabelMask.demo()
                    • LabelMask.to_multi_polygons()
                  • coco_make_track_gdf()
                  • imread_many()
                • geowatch.tasks.tracking.utils module
                  • trackid_is_default()
                  • check_only_bg()
                  • gpd_sort_by_gid()
                  • gpd_len()
                  • gpd_compute_scores()
                  • score_track_polys()
                  • score_poly()
                  • mask_to_polygons()
                • geowatch.tasks.tracking.visualize module
                  • visualize_videos()
                  • are_bas_dct()
                  • viz_track_scores()
              • Module contents
            • geowatch.tasks.uky_temporal_prediction package
              • Subpackages
              • Submodules
                • geowatch.tasks.uky_temporal_prediction.fit module
                  • main()
                • geowatch.tasks.uky_temporal_prediction.predict module
                  • extract_features()
                  • main()
                • geowatch.tasks.uky_temporal_prediction.time_sort_S7 module
                  • space7_sort
                    • space7_sort.head()
                    • space7_sort.forward()
                    • space7_sort.shared_step()
                    • space7_sort.training_step()
                    • space7_sort.validation_step()
                    • space7_sort.train_dataloader()
                    • space7_sort.val_dataloader()
                    • space7_sort.configure_optimizers()
                  • main()
                • geowatch.tasks.uky_temporal_prediction.time_sort_module module
                  • time_sort
                    • time_sort.head()
                    • time_sort.forward()
                    • time_sort.shared_step()
                    • time_sort.training_step()
                    • time_sort.validation_step()
                    • time_sort.train_dataloader()
                    • time_sort.val_dataloader()
                    • time_sort.configure_optimizers()
              • Module contents
          • Module contents
        • geowatch.utils package
          • Subpackages
            • geowatch.utils.lightning_ext package
              • Subpackages
                • geowatch.utils.lightning_ext.callbacks package
                  • Submodules
                    • geowatch.utils.lightning_ext.callbacks.auto_resumer module
                      • AutoResumer
                        • AutoResumer.on_init_start()
                        • AutoResumer.recent_checkpoints()
                    • geowatch.utils.lightning_ext.callbacks.batch_plotter module
                      • BatchPlotter
                        • BatchPlotter.setup()
                        • BatchPlotter.add_argparse_args()
                        • BatchPlotter.draw_batch()
                        • BatchPlotter.draw_if_ready()
                        • BatchPlotter.on_train_batch_end()
                        • BatchPlotter.on_validation_batch_end()
                        • BatchPlotter.on_test_batch_end()
                    • geowatch.utils.lightning_ext.callbacks.packager module
                      • Packager
                        • Packager.add_argparse_args()
                        • Packager.setup()
                        • Packager.on_fit_start()
                        • Packager.on_fit_end()
                        • Packager.on_exception()
                      • default_save_package()
                    • geowatch.utils.lightning_ext.callbacks.state_logger module
                      • StateLogger
                        • StateLogger.setup()
                        • StateLogger.teardown()
                        • StateLogger.on_fit_start()
                        • StateLogger.on_fit_end()
                        • StateLogger.on_save_checkpoint()
                        • StateLogger.on_sanity_check_start()
                        • StateLogger.on_sanity_check_end()
                        • StateLogger.on_exception()
                    • geowatch.utils.lightning_ext.callbacks.telemetry module
                      • LightningTelemetry
                        • LightningTelemetry.add_argparse_args()
                        • LightningTelemetry.setup()
                        • LightningTelemetry.on_fit_start()
                        • LightningTelemetry.on_fit_end()
                        • LightningTelemetry.on_train_epoch_end()
                        • LightningTelemetry.on_exception()
                    • geowatch.utils.lightning_ext.callbacks.tensorboard_plotter module
                      • TensorboardPlotter
                        • TensorboardPlotter.on_train_epoch_end()
                        • TensorboardPlotter.on_validation_epoch_end()
                        • TensorboardPlotter.on_test_epoch_end()
                    • geowatch.utils.lightning_ext.callbacks.text_logger module
                      • TextLogger
                        • TextLogger.setup()
                        • TextLogger.teardown()
                        • TextLogger.on_fit_start()
                        • TextLogger.on_fit_end()
                        • TextLogger.state_dict()
                        • TextLogger.load_state_dict()
                        • TextLogger.on_train_start()
                        • TextLogger.on_train_end()
                        • TextLogger.on_sanity_check_start()
                        • TextLogger.on_sanity_check_end()
                        • TextLogger.on_exception()
                        • TextLogger.on_train_epoch_start()
                        • TextLogger.on_train_epoch_end()
                        • TextLogger.on_validation_epoch_end()
                        • TextLogger.on_validation_epoch_start()
                  • Module contents
                    • AutoResumer
                      • AutoResumer.on_init_start()
                      • AutoResumer.recent_checkpoints()
                    • BatchPlotter
                      • BatchPlotter.add_argparse_args()
                      • BatchPlotter.draw_batch()
                      • BatchPlotter.draw_if_ready()
                      • BatchPlotter.on_test_batch_end()
                      • BatchPlotter.on_train_batch_end()
                      • BatchPlotter.on_validation_batch_end()
                      • BatchPlotter.setup()
                    • Packager
                      • Packager.add_argparse_args()
                      • Packager.on_exception()
                      • Packager.on_fit_end()
                      • Packager.on_fit_start()
                      • Packager.setup()
                    • StateLogger
                      • StateLogger.on_exception()
                      • StateLogger.on_fit_end()
                      • StateLogger.on_fit_start()
                      • StateLogger.on_sanity_check_end()
                      • StateLogger.on_sanity_check_start()
                      • StateLogger.on_save_checkpoint()
                      • StateLogger.setup()
                      • StateLogger.teardown()
                    • TensorboardPlotter
                      • TensorboardPlotter.on_test_epoch_end()
                      • TensorboardPlotter.on_train_epoch_end()
                      • TensorboardPlotter.on_validation_epoch_end()
                    • TextLogger
                      • TextLogger.load_state_dict()
                      • TextLogger.on_exception()
                      • TextLogger.on_fit_end()
                      • TextLogger.on_fit_start()
                      • TextLogger.on_sanity_check_end()
                      • TextLogger.on_sanity_check_start()
                      • TextLogger.on_train_end()
                      • TextLogger.on_train_epoch_end()
                      • TextLogger.on_train_epoch_start()
                      • TextLogger.on_train_start()
                      • TextLogger.on_validation_epoch_end()
                      • TextLogger.on_validation_epoch_start()
                      • TextLogger.setup()
                      • TextLogger.state_dict()
                      • TextLogger.teardown()
                    • default_save_package()
                    • LightningTelemetry
                      • LightningTelemetry.add_argparse_args()
                      • LightningTelemetry.on_exception()
                      • LightningTelemetry.on_fit_end()
                      • LightningTelemetry.on_fit_start()
                      • LightningTelemetry.on_train_epoch_end()
                      • LightningTelemetry.setup()
              • Submodules
                • geowatch.utils.lightning_ext.argparse_ext module
                  • get_init_arguments_and_types()
                  • str_to_bool_or_str()
                  • str_to_bool_or_int()
                  • str_to_bool()
                  • parse_docstring_args()
                  • add_arginfos_to_parser()
                  • add_argparse_args()
                • geowatch.utils.lightning_ext.demo module
                  • LightningToyNet2d
                    • LightningToyNet2d.forward()
                    • LightningToyNet2d.get_cfgstr()
                    • LightningToyNet2d.forward_step()
                    • LightningToyNet2d.validation_step()
                    • LightningToyNet2d.training_step()
                    • LightningToyNet2d.train_dataloader()
                    • LightningToyNet2d.val_dataloader()
                    • LightningToyNet2d.configure_optimizers()
                  • demo_trainer()
                • geowatch.utils.lightning_ext.lightning_cli_ext module
                  • LightningCLI_Extension
                    • LightningCLI_Extension.init_parser()
                    • LightningCLI_Extension.parse_arguments()
                • geowatch.utils.lightning_ext.monkeypatches module
                • geowatch.utils.lightning_ext.old_parser_devices module
                  • parse_gpu_ids()
                • geowatch.utils.lightning_ext.util_device module
                  • coerce_devices()
                  • coerce_accelerator_devices()
                • geowatch.utils.lightning_ext.util_globals module
                • geowatch.utils.lightning_ext.util_model module
                  • model_hparams()
              • Module contents
          • Submodules
            • geowatch.utils.configargparse_ext module
              • RawDescriptionDefaultsHelpFormatter
              • ArgumentParser
                • ArgumentParser.parse_known_args()
            • geowatch.utils.ext_monai module
              • FocalLoss
                • FocalLoss.forward()
              • DiceLoss
                • DiceLoss.forward()
              • MaskedDiceLoss
                • MaskedDiceLoss.forward()
              • GeneralizedWassersteinDiceLoss
                • GeneralizedWassersteinDiceLoss.forward()
                • GeneralizedWassersteinDiceLoss.wasserstein_distance_map()
              • DiceCELoss
                • DiceCELoss.ce()
                • DiceCELoss.forward()
              • DiceFocalLoss
                • DiceFocalLoss.forward()
              • Dice
              • dice_ce
              • dice_focal
              • generalized_wasserstein_dice
            • geowatch.utils.ijson_ext module
              • UnexpectedSymbol
              • utf8_encoder()
              • Lexer()
              • parse_value()
              • parse_string()
              • basic_parse_basecoro()
            • geowatch.utils.kwcoco_extensions module
              • filter_image_ids()
              • populate_watch_fields()
              • coco_populate_geo_heuristics()
              • coco_populate_geo_img_heuristics2()
              • coco_populate_geo_video_stats()
              • check_kwcoco_spatial_transforms()
              • check_geo_transform_consistency()
              • check_unique_channel_names()
              • coco_list_asset_infos()
              • check_geotiff_formats()
              • rewrite_geotiffs()
              • geotiff_format_info()
              • ensure_transfered_geo_data()
              • transfer_geo_metadata()
              • transfer_geo_metadata2()
              • coco_channel_stats()
              • TrackidGenerator
                • TrackidGenerator.update_generator()
                • TrackidGenerator.exclude_trackids()
              • coco_img_wld_info()
              • warp_annot_segmentations_from_geos()
              • warp_annot_segmentations_to_geos()
              • visualize_rois()
              • covered_image_geo_regions()
              • covered_video_geo_regions()
              • covered_annot_geo_regions()
              • associate_images()
              • reorder_video_frames()
              • pick_channels()
            • geowatch.utils.process_context module
            • geowatch.utils.remedian module
              • Remedian
                • Remedian.add_obs()
            • geowatch.utils.result_analysis module
              • Result
                • Result.to_dict()
                • Result.demo()
              • ResultTable
                • ResultTable.table
                • ResultTable.result_list
                • ResultTable.demo()
                • ResultTable.coerce()
                • ResultTable.varied
              • ResultAnalysis
                • ResultAnalysis.demo()
                • ResultAnalysis.run()
                • ResultAnalysis.analysis()
                • ResultAnalysis.table
                • ResultAnalysis.metric_table()
                • ResultAnalysis.varied
                • ResultAnalysis.abaltion_groups()
                • ResultAnalysis.tune()
                • ResultAnalysis.ablate()
                • ResultAnalysis.abalation_groups()
                • ResultAnalysis.abalate()
                • ResultAnalysis.test_group()
                • ResultAnalysis.build()
                • ResultAnalysis.report()
                • ResultAnalysis.conclusions()
                • ResultAnalysis.plot()
              • SkillTracker
                • SkillTracker.predict_win()
                • SkillTracker.observe()
              • UnhashablePlaceholder
              • varied_values()
              • varied_value_counts()
              • GroupbyFutureWrapper
              • fix_groupby()
              • aggregate_stats()
              • stats_dict()
              • combine_stats()
              • combine_stats_arrs()
            • geowatch.utils.reverse_hashid module
              • ReverseHashTable
                • ReverseHashTable.load()
                • ReverseHashTable.register()
                • ReverseHashTable.query()
              • condense_config()
            • geowatch.utils.simple_dvc module
              • SimpleDVC
                • SimpleDVC.init()
                • SimpleDVC.cache_dir
                • SimpleDVC.demo_dpath()
                • SimpleDVC.coerce()
                • SimpleDVC.find_root()
                • SimpleDVC.add()
                • SimpleDVC.pathsremove()
                • SimpleDVC.check_ignore()
                • SimpleDVC.git_pull()
                • SimpleDVC.git_push()
                • SimpleDVC.git_commit()
                • SimpleDVC.git_commitpush()
                • SimpleDVC.push()
                • SimpleDVC.pull()
                • SimpleDVC.request()
                • SimpleDVC.unprotect()
                • SimpleDVC.is_tracked()
                • SimpleDVC.find_file_tracker()
                • SimpleDVC.find_dir_tracker()
                • SimpleDVC.read_dvc_sidecar()
                • SimpleDVC.resolve_cache_paths()
                • SimpleDVC.find_sidecar_paths()
                • SimpleDVC.resolve_sidecar()
              • SimpleDVC_CLI
                • SimpleDVC_CLI.Add
                  • SimpleDVC_CLI.Add.main()
                  • SimpleDVC_CLI.Add.default
                • SimpleDVC_CLI.Request
                  • SimpleDVC_CLI.Request.main()
                  • SimpleDVC_CLI.Request.default
                • SimpleDVC_CLI.CacheDir
                  • SimpleDVC_CLI.CacheDir.main()
                  • SimpleDVC_CLI.CacheDir.default
            • geowatch.utils.util_bands module
              • Sentinal 2 Band Table
              • Landsat 8 Band Table
              • Worldview 3 MUL Band Table
              • Worldview 3 PAN Band Table
              • dicts_contain()
              • SENTINEL2
              • LANDSAT8
              • LANDSAT7
              • PLANETSCOPE_8BAND
              • ALL_BANDS
              • EO_COMMONNAMES
              • GROUND
              • specialized_index_bands()
              • specialized_index_bands2()
            • geowatch.utils.util_codes module
              • parse_delimited_argstr()
            • geowatch.utils.util_data module
              • DataRegistry
                • DataRegistry.pandas()
                • DataRegistry.list()
                • DataRegistry.add()
                • DataRegistry.set()
                • DataRegistry.remove()
                • DataRegistry.read()
                • DataRegistry.query()
                • DataRegistry.find()
              • find_dvc_dpath()
              • find_smart_dvc_dpath()
            • geowatch.utils.util_dotdict module
              • dotdict_to_nested()
              • dotkeys_to_nested()
              • DotDict
                • DotDict.from_nested()
                • DotDict.to_nested()
                • DotDict.to_nested_keys()
                • DotDict.prefix_get()
                • DotDict.add_prefix()
                • DotDict.insert_prefix()
                • DotDict.print_graph()
                • DotDict.query_keys()
              • indexable_to_graph()
              • explore_nested_dict()
            • geowatch.utils.util_exception module
            • geowatch.utils.util_framework module
              • egress_item()
              • ingress_item()
              • download_mtd_msil1c()
              • download_file()
              • download_http_file()
              • CacheItemOutputS3Wrapper
              • IngressProcessEgressWrapper
              • download_region()
              • determine_region_id()
              • AWS_S3_Command
                • AWS_S3_Command.cmd_known_flags
                • AWS_S3_Command.cmd_known_keyvals
                • AWS_S3_Command.update()
                • AWS_S3_Command.finalize()
                • AWS_S3_Command.run()
              • ta2_collate_output()
              • fixup_and_validate_site_and_region_models()
              • check_region_and_site_models_agree()
              • NodeStateDebugger
                • NodeStateDebugger.print_environment()
                • NodeStateDebugger.print_local_invocation()
                • NodeStateDebugger.print_current_state()
                • NodeStateDebugger.print_directory_contents()
              • PrintLogger
                • PrintLogger.info()
                • PrintLogger.debug()
                • PrintLogger.error()
                • PrintLogger.warning()
                • PrintLogger.critical()
            • geowatch.utils.util_fsspec module
              • FSPath
                • FSPath.get_filesystem_class()
                • FSPath.fs
                • FSPath.coerce()
                • FSPath.path
                • FSPath.relative_to()
                • FSPath.is_remote()
                • FSPath.is_local()
                • FSPath.open()
                • FSPath.ls()
                • FSPath.touch()
                • FSPath.move()
                • FSPath.delete()
                • FSPath.rm()
                • FSPath.mkdir()
                • FSPath.stat()
                • FSPath.is_dir()
                • FSPath.is_file()
                • FSPath.is_link()
                • FSPath.exists()
                • FSPath.write_text()
                • FSPath.read_text()
                • FSPath.walk()
                • FSPath.parent
                • FSPath.name
                • FSPath.stem
                • FSPath.suffix
                • FSPath.suffixes
                • FSPath.parts
                • FSPath.copy()
                • FSPath.joinpath()
                • FSPath.tree()
              • LocalPath
                • LocalPath.ensuredir()
                • LocalPath.absolute()
                • LocalPath.appdir()
              • MemoryPath
              • RemotePath
              • S3Path
                • S3Path.ensuredir()
                • S3Path.register_bucket()
                • S3Path.coerce()
              • SSHPath
                • SSHPath.host
            • geowatch.utils.util_gdal module
            • geowatch.utils.util_girder module
              • grabdata_girder()
            • geowatch.utils.util_gis module
              • utm_epsg_from_zoneletter()
            • geowatch.utils.util_globals module
              • configure_global_attributes()
            • geowatch.utils.util_hardware module
              • get_cpu_mem_info()
              • get_cpu_info()
              • get_mem_info()
              • disk_info_of_path()
            • geowatch.utils.util_iter module
              • consume()
              • chunks()
            • geowatch.utils.util_kwarray module
              • cartesian_product()
              • tukey_biweight_loss()
              • asymptotic()
              • robust_limits()
              • unique_rows()
              • find_robust_normalizers()
              • apply_normalizer()
              • normalize()
              • balanced_number_partitioning()
              • torch_array_equal()
              • combine_mean_stds()
              • apply_robust_normalizer()
              • biased_1d_weights()
              • argsort_threshold()
            • geowatch.utils.util_kwimage module
              • upweight_center_mask()
              • perchannel_colorize()
              • ensure_false_color()
              • colorize_label_image()
              • local_variance()
              • find_lowvariance_regions()
              • find_samecolor_regions()
              • find_high_frequency_values()
              • polygon_distance_transform()
              • multiple_polygon_distance_transform_weighting()
              • devcheck_frame_poly_weights()
              • find_low_overlap_covering_boxes()
              • find_low_overlap_covering_boxes_optimize()
              • exactly_1channel()
              • load_image_shape()
              • draw_multiclass_clf_on_image()
            • geowatch.utils.util_kwplot module
              • TitleBuilder
                • TitleBuilder.add_part()
                • TitleBuilder.newline()
                • TitleBuilder.ensure_newline()
                • TitleBuilder.finalize()
              • cropwhite_ondisk()
              • dataframe_table()
              • humanize_dataframe()
              • scatterplot_highlight()
              • humanize_labels()
              • relabel_xticks()
              • LabelModifier
                • LabelModifier.copy()
                • LabelModifier.add_mapping()
                • LabelModifier.update()
                • LabelModifier.relabel_yticks()
                • LabelModifier.relabel_xticks()
                • LabelModifier.relabel_axes_labels()
                • LabelModifier.relabel_legend()
                • LabelModifier.relabel()
              • FigureFinalizer
                • FigureFinalizer.copy()
                • FigureFinalizer.update()
                • FigureFinalizer.finalize()
              • fix_matplotlib_dates()
              • fix_matplotlib_timedeltas()
              • extract_legend()
              • ArtistManager
                • ArtistManager.plot()
                • ArtistManager.add_linestring()
                • ArtistManager.add_ellipse()
                • ArtistManager.add_circle()
                • ArtistManager.add_ellipse_marker()
                • ArtistManager.add_circle_marker()
                • ArtistManager.build_collections()
                • ArtistManager.add_to_axes()
                • ArtistManager.bounds()
                • ArtistManager.setlims()
              • time_sample_arcplot()
              • Palette
                • Palette.coerce()
                • Palette.update()
                • Palette.add_labels()
                • Palette.make_legend_img()
                • Palette.sorted_keys()
                • Palette.reorder()
              • PaletteManager
              • color_new_labels()
              • autompl2()
              • FigureManager
                • FigureManager.figure()
                • FigureManager.finalize()
                • FigureManager.set_figtitle()
              • fix_seaborn_palette_issue()
            • geowatch.utils.util_kwutil module
              • distributed_subitems()
              • farthest_first()
            • geowatch.utils.util_logging module
              • setup_logging()
              • get_logger()
              • PrintLogger
                • PrintLogger.setLevel()
                • PrintLogger.debug()
                • PrintLogger.info()
                • PrintLogger.warning()
                • PrintLogger.error()
                • PrintLogger.exception()
                • PrintLogger.critical()
                • PrintLogger.log()
                • PrintLogger.findCaller()
                • PrintLogger.makeRecord()
                • PrintLogger.filter()
                • PrintLogger.handle()
                • PrintLogger.addHandler()
                • PrintLogger.removeHandler()
                • PrintLogger.hasHandlers()
                • PrintLogger.callHandlers()
                • PrintLogger.getEffectiveLevel()
                • PrintLogger.isEnabledFor()
                • PrintLogger.getChild()
            • geowatch.utils.util_nesting module
              • debug_shapes()
              • shape_summary()
            • geowatch.utils.util_netharn module
              • Optimizer
                • Optimizer.coerce()
              • Initializer
                • Initializer.forward()
                • Initializer.history()
                • Initializer.get_initkw()
                • Initializer.coerce()
              • NoOp
                • NoOp.forward()
              • Orthogonal
                • Orthogonal.forward()
              • KaimingUniform
                • KaimingUniform.forward()
              • KaimingNormal
                • KaimingNormal.forward()
              • apply_initializer()
              • trainable_layers()
              • number_of_parameters()
              • ToyNet2d
                • ToyNet2d.forward()
              • ToyData2d
                • ToyData2d.make_loader()
              • InputNorm
                • InputNorm.forward()
              • MultiLayerPerceptronNd
                • MultiLayerPerceptronNd.forward()
              • rectify_dropout()
              • rectify_nonlinearity()
              • rectify_normalizer()
              • Identity
              • Conv0d
                • Conv0d.forward()
                • Conv0d.extra_repr()
              • Conv1d
                • Conv1d.forward()
                • Conv1d.extra_repr()
              • Conv2d
                • Conv2d.forward()
                • Conv2d.extra_repr()
              • Conv3d
                • Conv3d.forward()
                • Conv3d.extra_repr()
              • rectify_conv()
              • weight_standardization_nd()
              • ConvNormNd
              • ConvNorm1d
              • ConvNorm2d
              • ConvNorm3d
              • Swish
                • Swish.forward()
              • beta_mish()
              • Mish_Function
                • Mish_Function.forward()
                • Mish_Function.backward()
              • Mish
                • Mish.forward()
              • default_kwargs()
              • CollateException
              • padded_collate()
            • geowatch.utils.util_nvidia module
              • NvidiaSMIError
              • nvidia_smi()
            • geowatch.utils.util_pandas module
              • DataFrame
                • DataFrame.random()
                • DataFrame.coerce()
                • DataFrame.safe_drop()
                • DataFrame.reorder()
                • DataFrame.groupby()
                • DataFrame.match_columns()
                • DataFrame.search_columns()
                • DataFrame.varied_values()
                • DataFrame.varied_value_counts()
                • DataFrame.shorten_columns()
                • DataFrame.argextrema()
              • pandas_reorder_columns()
              • pandas_argmaxima()
              • pandas_suffix_columns()
              • pandas_nan_eq()
              • pandas_shorten_columns()
              • pandas_condense_paths()
              • pandas_truncate_items()
              • DotDictDataFrame
                • DotDictDataFrame.nested_columns
                • DotDictDataFrame.find_column()
                • DotDictDataFrame.query_column()
                • DotDictDataFrame.lookup_suffix_columns()
                • DotDictDataFrame.lookup_prefix_columns()
                • DotDictDataFrame.find_columns()
                • DotDictDataFrame.match_columns()
                • DotDictDataFrame.search_columns()
                • DotDictDataFrame.subframe()
              • pandas_add_prefix()
              • aggregate_columns()
              • SpecialAggregators
                • SpecialAggregators.hash()
                • SpecialAggregators.hash12()
                • SpecialAggregators.unique()
                • SpecialAggregators.min_max()
                • SpecialAggregators.normalize_special_key()
                • SpecialAggregators.special_lut
              • NonConstantError
              • nan_eq()
              • GroupbyFutureWrapper
              • pandas_fixed_groupby()
            • geowatch.utils.util_param_grid module
              • handle_yaml_grid()
              • coerce_list_of_action_matrices()
              • prevalidate_param_grid()
              • expand_param_grid()
              • github_action_matrix()
              • extended_github_action_matrix()
            • geowatch.utils.util_raster module
              • mask()
              • ResampledRaster
                • ResampledRaster.raster
                • ResampledRaster.scale
                • ResampledRaster.read
                • ResampledRaster.resampling
            • geowatch.utils.util_regex module
              • VimRegexBuilder
              • PythonRegexBuilder
            • geowatch.utils.util_resolution module
              • ExtendedTransformer
                • ExtendedTransformer.parser()
                • ExtendedTransformer.parse()
              • ResolvedTransformer
                • ResolvedTransformer.magnitude()
                • ResolvedTransformer.unit()
                • ResolvedTransformer.implicit_unit()
                • ResolvedTransformer.numeric_unit()
                • ResolvedTransformer.resolved_unit()
              • ResolvedUnitTransformer
              • ResolvedScalarTransformer
                • ResolvedScalarTransformer.resolved_scalar()
              • ResolvedWindowTransformer
                • ResolvedWindowTransformer.window_1d_dim()
                • ResolvedWindowTransformer.window_2d_dim()
                • ResolvedWindowTransformer.window()
                • ResolvedWindowTransformer.resolved_window()
              • Resolved
                • Resolved.parse()
                • Resolved.coerce()
              • ResolvedUnit
                • ResolvedUnit.coerce()
              • ResolvedScalar
                • ResolvedScalar.at_resolution()
              • ResolvedWindow
                • ResolvedWindow.at_resolution()
            • geowatch.utils.util_retry module
              • DummyLogger
                • DummyLogger.warning()
              • Retry
              • retry_call()
            • geowatch.utils.util_rgdc module
            • geowatch.utils.util_s3 module
              • get_file_from_s3()
              • send_file_to_s3()
            • geowatch.utils.util_stringalgo module
              • shortest_unique_prefixes()
              • shortest_unique_suffixes()
            • geowatch.utils.util_torchmetrics module
              • BinaryF1Score
                • BinaryF1Score.compute()
              • BinaryOverallAccuracy
                • BinaryOverallAccuracy.compute()
              • BinaryBalancedAccuracy
                • BinaryBalancedAccuracy.compute()
              • BinaryTruePositiveRate
                • BinaryTruePositiveRate.compute()
            • geowatch.utils.util_units module
              • unit_registry()
          • Module contents
            • find_dvc_dpath()
            • find_smart_dvc_dpath()
      • Submodules
        • geowatch.exceptions module
        • geowatch.heuristics module
          • DEFAULT_QA_ENCODING
          • IARPA_REAL_STATUS
          • iarpa_assign_truth_confusion()
          • iarpa_assign_pred_confusion()
          • TAG_IF()
          • CONDITION()
          • ALL()
          • hack_track_categories()
          • ensure_heuristic_coco_colors()
          • ensure_heuristic_category_tree_colors()
          • category_tree_ensure_color()
          • category_category_colors()
          • dummy_legend()
          • build_image_header_text()
          • auto_expt_dvc()
          • auto_data_dvc()
          • normalize_sensors()
          • extract_region_id()
          • register_known_fsspec_s3_buckets()
      • Module contents
        • coerce_kwcoco()
        • find_dvc_dpath()
        • find_smart_dvc_dpath()
  • Manual Docs
    • GeoWATCH System
    • Sensor Channel Spec
    • TA2 Deep Dive Notes
    • Baseline 2023-06-22 BAS
    • Baseline 2023-06-22 Joint BAS+AC/SC
    • Tips and Tricks
    • Troubleshooting
    • Baseline 2023-06-22 Joint AC/SC Truth
    • Baseline 2023-10-12 Full
    • Baseline 2024-06-11 BAS
    • Variation 2023-11-14 Full
    • Beginner’s Python
      • Python Keywords
      • Dunder Methods
      • Standard Library Modules
      • Pypi Modules
      • Builtins
      • Advanced Terms
      • Python Package Structure / Importing
    • Accessing GeoWATCH DVC Repos
      • Prerequistes
      • Clone the Repos
      • Access data in the Data DVC repo
    • Accessing Phase3 GeoWATCH DVC Repos
      • Prerequistes
      • Clone the Repos
      • Register Repos
      • Access Data
    • Internal Resources
    • Using GeoWATCH DVC
    • Debugging Cmd-Queue Powered Scripts
    • Coding Conventions in the GeoWATCH REPO
      • Spaces
    • Coding Environment
      • Enable Argcomplete
      • Useful Aliases
    • Coding Tips
    • Valuable Code Properties
      • Code Patterns
      • Testing
      • Filesystems
    • Misc
    • Contributing New Models to the WATCH Project
      • Assumptions:
      • Steps to sharing your model:
      • Whats going on behind the scenes:
    • How to Contribute
    • Forking Workflow
    • Rebasing Procedure
    • Roadmap
      • Features
      • Quality of Life
      • Bugs
      • Performance
      • Research
      • Compatibility
      • Documentation
      • System Design
      • Algorithmic Exploration
      • User Interface
    • TA2 Feature Integration
    • Getting started with AWS
      • Installing AWS CLI
      • AWS Credentials
        • Obtaining Credentials
        • Using Credentials
      • AWS Security
      • Next Steps
    • Minimal DVC
    • Installation
    • Core Commands
    • Details
    • Use Cases
    • Getting started with AWS
      • Prerequisites
      • Install Kubernetes CLI
      • Next Steps
    • Getting started with PostgreSQL
    • Setup your SSH Keys
      • Generating SSH Keys
      • Register SSH Keys with a Gitlab
      • Modify An Existing Clone to Use SSH
      • Register SSH Keys with a DVC server
      • Troubleshooting SSH Keys
    • Installing Python
    • Installing Python With Conda
      • Create GeoWATCH Environment with Conda
    • Installing Pyenv
      • Create GeoWATCH environment with Pyenv
    • Installing GeoWATCH For Development
      • Option 1: Local Install
        • Install Python
        • Non-Python Requirements
        • Installing
        • Submodules
        • Testing
      • Option 2: Docker Image
    • Understanding Editable Installs
      • Installing to Site Packages
    • See Also
    • GeoWATCH On Windows
      • Installer Miniconda
      • Install Bash
      • Environment Setup
      • Optional: Installing From Source
      • Running The Tutorial
        • WSL2 Instructions
      • Running on WSL2
    • Examles
    • FAQ on CloudMasks
      • Question
      • Answer
    • FAQ: Model Prediction
      • Question
      • Answer
    • FAQ: STAC
      • Question
      • Answer
    • Refactoring Datasets and Models
      • The Model
      • The Dataset
      • Ambiguous / Other
    • Directory Structure for Multi-task Integration
      • Design Goals (2021):
      • Design Goals (2023):
      • Directory Structure:
        • Usage:
        • Fit API:
        • Predict API:
        • Evaluation:
      • Examples:
    • Supporting Projects
    • Using the MLOps tool to run GeoWATCH
      • using DVC and geowatch_dvc
        • sidebar: setting up a shared DVC cache on a shared machine
      • using mlops to checkout a model
      • using mlops to run an evaluation
      • debugging/examining a running mlops invocation
        • sidebar: help, my predict step is hanging!
      • What does an mlops invocation run?
    • GeoWATCH Onboarding
      • Tutorials
      • Module Structure
    • GeoWATCH Overview
      • KWCOCO Data Interchange
      • Semantically Rich Features
      • Training Pipeline
      • Prediction Pipeline
      • Software Testing
      • MLOps
      • Relationship to RasterVision
    • SMART Activity Characterization Tutorial
      • 1. Access AC Data
      • 2. Modify AC Data
      • 3. Train an AC Model
      • 4. Evaluate an AC Model with MLOps
    • SMART Ensemble Tutorial
    • Getting Started With Smartflow
      • Requirements
      • Configure Kubernetes
      • Troubleshooting
      • Running the Webserver
      • References
      • Next Steps
      • SeeAlso
    • Copying Large Files to EFS
      • Prerequisites
      • AWS Configuration
      • Configuring kubctl to reach smartflow
        • rsync and kubernetes
    • Connecting to Smartflow
    • Launch a KIT_DEMO_WAIT job
    • Finally we can copy!
    • Common pitfalls
    • Running The System In Smartflow
      • Prerequisites
      • Section 0: NOTICE OF AUTOMATION
      • Section 1: The GeoWATCH Docker Image
        • Building the Pyenv Base Image
        • Building the GeoWATCH Image
        • How to Bake a Model into a Pyenv Dockerfile
        • Update An Existing Image
      • How to Submit a DAG
      • Building / Modifying a DAG
        • Running DAGS
        • Debuggging DAGS
      • Old Notes
        • How to Bake a Model into a Dockerfile (OLD)
        • Running Dags After Containers are Using (OLD)
        • SeeAlso
    • Prerequisites
      • AWS Configuration
      • Configuring kubctl to reach smartflow
    • Connecting to Smartflow
    • Launch a KIT_TRAIN_WITH_YAML job
    • Copying your own DAG to Smartflow’s S3 Bucket
    • Logging into a running DAG step / K8s pod
    • Running CI Locally
    • Running tests
    • Writing tests
    • Tutorials
    • Important GeoWATCH Scripts
    • Summary of GeoWATCH Scripts
      • Main Commands / Scripts
      • Dataset Preparation / Management
      • Production / Prediction / Evaluation
      • Secondary Scripts
    • The “geowatch_dvc” command
geowatch
  • geowatch
  • geowatch package
  • geowatch.tasks package
  • geowatch.tasks.metrics package
  • View page source

geowatch.tasks.metrics package¶

Submodules¶

  • geowatch.tasks.metrics.merge_iarpa_metrics module
    • RegionResult
      • RegionResult.region_id
      • RegionResult.region_model
      • RegionResult.site_models
      • RegionResult.bas_dpath
      • RegionResult.sc_dpath
      • RegionResult.unbounded_site_status
      • RegionResult.from_dpath_and_anns_root()
      • RegionResult.bas_df
      • RegionResult.site_ids
      • RegionResult.sc_df
      • RegionResult.sc_te_df
      • RegionResult.sc_phasetable
    • merge_bas_metrics_results()
    • merge_sc_metrics_results()
    • merge_metrics_results()
    • iarpa_bas_color_legend()
  • geowatch.tasks.metrics.viz_sc_results module
    • viz_sc()
    • viz_sc_gantt()
    • viz_sc_multi()

Module contents¶

Previous Next

© Copyright 2024, GeoWATCH developers Kitware Inc. Jon Crall.

Built with Sphinx using a theme provided by Read the Docs.