From 552e53868f6dc9dde63fab2fb600172cebac8b23 Mon Sep 17 00:00:00 2001 From: sschmidt23 Date: Wed, 28 Jan 2026 14:20:33 -0800 Subject: [PATCH 01/11] prelim cardinal reducer --- src/rail/projects/reducer.py | 151 ++++++++++++++++++++++++++++++---- tests/ci_algorithms.yaml | 5 ++ tests/ci_project_library.yaml | 5 ++ 3 files changed, 147 insertions(+), 14 deletions(-) diff --git a/src/rail/projects/reducer.py b/src/rail/projects/reducer.py index fb2cd19..ab716ef 100644 --- a/src/rail/projects/reducer.py +++ b/src/rail/projects/reducer.py @@ -65,27 +65,53 @@ COLUMNS_FLAGSHIP = [ "galaxy_id", - "ra_mag_gal", # observed galaxy ra/dec with lensing displacement field applied [degrees] + "ra_mag_gal", # observed galaxy ra/dec with lensing displacement field applied [degrees] "dec_mag_gal", - "lsst_u_el_model3_ext", # observed flux from the continuum + emission including internal attenuation in LSST bands + "lsst_u_el_model3_ext", # observed flux from the continuum + emission including internal attenuation in LSST bands "lsst_g_el_model3_ext", "lsst_r_el_model3_ext", "lsst_i_el_model3_ext", "lsst_z_el_model3_ext", "lsst_y_el_model3_ext", - "euclid_nisp_h_el_model3_ext", # euclid bands (noiseless) + "euclid_nisp_h_el_model3_ext", # euclid bands (noiseless) "euclid_nisp_j_el_model3_ext", "euclid_nisp_y_el_model3_ext", "euclid_vis_el_model3_ext", - "bulge_r50", # half light radius of the bulge [arcsec] - "disk_r50", # half light radius of the disk for an exponential profile (or Sersic profile with index n=1); disk_r50 = disk_scalelength * 1.678 [arcsec] - "bulge_fraction", # ratio of the flux in the bulge component to the total flux (often written B/T) - "gamma1", # shape contribution from lensing, not large but added for consistency + "bulge_r50", # half light radius of the bulge [arcsec] + "disk_r50", # half light radius of the disk for an exponential profile (or Sersic profile with index n=1); disk_r50 = disk_scalelength * 1.678 [arcsec] + "bulge_fraction", # ratio of the flux in the bulge component to the total flux (often written B/T) + "gamma1", # shape contribution from lensing, not large but added for consistency "gamma2", - "eps1_gal", # intrinsic galaxy ellipticity component + "eps1_gal", # intrinsic galaxy ellipticity component "eps2_gal", ] +COLUMNS_CARDINAL = [ + "galaxy_id", + "ra", + "dec", + "sedid", + "size", + "Ellipticity_1", + "Ellipticity_2", + "mag_u_lsst", + "mag_g_lsst", + "mag_r_lsst", + "mag_i_lsst", + "mag_z_lsst", + "mag_y_lsst", + "Roman_Y106", + "Roman_J129", + "Roman_H158", + "Roman_F184", + "Roman_K213", + "redshift", + "Euclid_Y", + "Euclid_J", + "Euclid_H", + "Euclid_redshift" +] + PROJECTIONS_COM_CAM = [ { "ref_flux": pc.field("i_cModelFlux"), @@ -99,6 +125,16 @@ } ] +PROJECTIONS_CARDINAL = [ + { + # "Roman_K213": pc.field("k213"), + "Ellipticity1": pc.field("Ellipticity_1"), + "Ellipticity2": pc.field("Ellipticity_2"), + # "galaxy_id": pc.field("id") + } +] + + PROJECTIONS = [ { "mag_u_lsst": pc.field("LSST_obs_u"), @@ -188,7 +224,7 @@ ), ), "_orientationAngle": pc.atan2( - pc.add(pc.field("eps2_gal"), pc.field("gamma2")), + pc.add(pc.field("eps2_gal"), pc.field("gamma2")), pc.add(pc.field("eps1_gal"), pc.field("gamma1")) ), }, @@ -196,16 +232,16 @@ "major": pc.divide( pc.field("totalHalfLightRadiusArcsec"), pc.sqrt( - pc.sqrt(pc.add(pc.power(pc.add(pc.field("eps1_gal"), pc.field("gamma1")), 2), + pc.sqrt(pc.add(pc.power(pc.add(pc.field("eps1_gal"), pc.field("gamma1")), 2), pc.power(pc.add(pc.field("eps2_gal"), pc.field("gamma2")), 2))) - ), + ), ), "minor": pc.multiply( pc.field("totalHalfLightRadiusArcsec"), pc.sqrt( - pc.sqrt(pc.add(pc.power(pc.add(pc.field("eps1_gal"), pc.field("gamma1")), 2), + pc.sqrt(pc.add(pc.power(pc.add(pc.field("eps1_gal"), pc.field("gamma1")), 2), pc.power(pc.add(pc.field("eps2_gal"), pc.field("gamma2")), 2))) - ), + ), ), "orientationAngle": pc.multiply( pc.scalar(0.5), @@ -350,6 +386,93 @@ def run( pq.write_table(table, output_catalog) +class CardinalReducer(RailReducer): + """Class to reduce the 'Cardinal' simulation input files for pz analysis + Note that cardinal native files are fits files split into triplets, a + preprocessing stage was performed to put them into pyarrow parquet + """ + + config_options: dict[str, StageParameter] = dict( + name=StageParameter(str, None, fmt="%s", required=True, msg="Reducer Name"), + cuts=StageParameter(dict, {}, fmt="%s", msg="Selections"), + ) + + def run( + self, + input_catalog: str, + output_catalog: str, + ) -> None: + # Try to do this right + try: + parsed_filter = parse_item(self.config.cuts) + predicate = pq.filters_to_expression(parsed_filter) + except Exception as msg: + # Fallback to old way. FIXME, deprecate this + if self.config.cuts: + if "maglim_i" in self.config.cuts: + predicate = pc.field("mag_i_lsst") < self.config.cuts["maglim_i"][1] + elif "maglim_Y" in self.config.cuts: + predicate = ( + pc.field("Roman_Y106") < self.config.cuts["maglim_Y"][1] + ) + else: + raise ValueError("No valid cut") from msg + else: # pragma: no cover + predicate = None + + dataset = ds.dataset( + input_catalog, + format="parquet", + ) + + scan_node = acero.Declaration( + "scan", + acero.ScanNodeOptions( + dataset, + columns=COLUMNS_CARDINAL, + filter=predicate, + ), + ) + + filter_node = acero.Declaration( + "filter", + acero.FilterNodeOptions( + predicate, + ), + ) + + column_projection = {k: pc.field(k) for k in COLUMNS_CARDINAL} + projection = column_projection + project_nodes = [] + for _projection in PROJECTIONS_CARDINAL: + for k, v in _projection.items(): + projection[k] = v + project_node = acero.Declaration( + "project", + acero.ProjectNodeOptions( + [v for k, v in projection.items()], + names=[k for k, v in projection.items()], + ), + ) + project_nodes.append(project_node) + + seq = [ + scan_node, + filter_node, + *project_nodes, + ] + plan = acero.Declaration.from_sequence(seq) + + # batches = plan.to_reader(use_threads=True) + table = plan.to_table(use_threads=True) + print(f"writing dataset to {output_catalog}") + + output_dir = os.path.dirname(output_catalog) + + os.makedirs(output_dir, exist_ok=True) + pq.write_table(table, output_catalog) + + class FlagshipReducer(RailReducer): """Class to reduce the 'flagship' simulation input files for pz analysis""" @@ -368,7 +491,7 @@ def run( parsed_filter = parse_item(self.config.cuts) predicate = pq.filters_to_expression(parsed_filter) except Exception as msg: - # Fallback to old way. FIXME, deprecate this + # Fallback to old way. FIXME, deprecate this if self.config.cuts: if "maglim_i" in self.config.cuts: predicate = pc.subtract(pc.multiply(pc.scalar(-2.5), pc.log10(pc.field("lsst_i_el_model3_ext"))), pc.scalar(48.6)) < self.config.cuts["maglim_i"][1] diff --git a/tests/ci_algorithms.yaml b/tests/ci_algorithms.yaml index 4cac99f..db5f3f4 100644 --- a/tests/ci_algorithms.yaml +++ b/tests/ci_algorithms.yaml @@ -120,3 +120,8 @@ Reducers: name: flagship Reduce: FlagshipReducer Module: rail.projects.reducer + + - Reducer: + name: cardinal + Reduce: CardinalReducer + Module: rail.projects.reducer diff --git a/tests/ci_project_library.yaml b/tests/ci_project_library.yaml index af832a2..fc430c1 100644 --- a/tests/ci_project_library.yaml +++ b/tests/ci_project_library.yaml @@ -197,6 +197,11 @@ Reducers: Reduce: FlagshipReducer Module: rail.projects.reducer + - Reducer: + name: cardinal + Reduce: CardinalReducer + Module: rail.projects.reducer + # These describe the various data analysis pipelines Pipelines: From d430b7c3825708ebe2bda197814993cca636b904 Mon Sep 17 00:00:00 2001 From: sschmidt23 Date: Wed, 28 Jan 2026 16:02:10 -0800 Subject: [PATCH 02/11] forgot yaml files --- tests/ci_cardinal_project_library.yaml | 467 +++++++++++++++++++++++++ tests/ci_project-cardinal.yaml | 54 +++ 2 files changed, 521 insertions(+) create mode 100644 tests/ci_cardinal_project_library.yaml create mode 100644 tests/ci_project-cardinal.yaml diff --git a/tests/ci_cardinal_project_library.yaml b/tests/ci_cardinal_project_library.yaml new file mode 100644 index 0000000..6a6f2da --- /dev/null +++ b/tests/ci_cardinal_project_library.yaml @@ -0,0 +1,467 @@ +# This is the "library" of common defintions shared between similar projects + +# Templates we use to define catalogs +# +# A CatalogTemplate can be given several interpolants to resolve to a specific Catalog +# +# Some of the interpolants [{catalogs_dir}, {project}, {sim_version}] +# are defined in the Project CommonPaths block +# +# Possibles values of {selection} are defined the the library "Selections" block +# +# Possible values of {flavor} are defined the the Project "Flavors" block +Catalogs: + # The input "Truth" catalog + - CatalogTemplate: + name: truth + path_template: "{catalogs_dir}/Chinchilla-3-triofile.{healpix}.1pct.parquet" + iteration_vars: ['healpix'] + # Catalogs that have been reduced using a particular selection + - CatalogTemplate: + name: reduced + path_template: "{catalogs_dir}/{project}_{selection}/{healpix}/Chinchilla-3-triofile.1pct.pq" + iteration_vars: ['healpix'] + # Data output from running some degraders on the original catalog + # Note that the {basename} can be used to select which degraded output we want + - CatalogTemplate: + name: degraded + path_template: "{catalogs_dir}/{project}_{selection}_{flavor}/{healpix}/{basename}" + iteration_vars: ['healpix'] + + +# This file describes the templates we use to define files and specfic instances +# of files +# +# A FileTemplate can be given several interpolants to resolve to a specific FileInstance +# +# Some of the interpolants [{catalogs_dir}, {project}] +# are defined in the Project CommonPaths block +# +# Possibles values of {selection} are defined the the library "Selections" block +Files: + # Testing data file + - FileTemplate: + name: test_file_100k + path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_100k.hdf5" + # Generic training data file + - FileTemplate: + name: train_file_100k + path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_100k.hdf5" + # Training file with a non-representative sample from the zCOSMOS selection + - FileTemplate: + name: train_file_zCOSMOS_100k + path_template: "{catalogs_dir}/train/{project}_{selection}_zCOSMOS_100k.hdf5" + # Small trainng file + - FileTemplate: + name: train_file_10 + path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_10.hdf5" + - FileTemplate: + name: test_split_file + path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_split_test_10.hdf5" + - FileTemplate: + name: train_split_file + path_template: "{catalogs_dir}/train/{project}_{selection}_baseline_split_train_10.hdf5" + - FileTemplate: + name: deep_file_full + path_template: "{catalogs_dir}/som/{project}_deep_data_full.hdf5" + - FileTemplate: + name: deep_file_small + path_template: "{catalogs_dir}/som/{project}_deep_data_small.hdf5" + - FileTemplate: + name: wide_file_full + path_template: "{catalogs_dir}/som/{project}_wide_data_full.hdf5" + - FileTemplate: + name: wide_file_small + path_template: "{catalogs_dir}/som/{project}_wide_data_small.hdf5" + - FileTemplate: + name: spec_file_full + path_template: "{catalogs_dir}/som/{project}_spec_data_full.hdf5" + - FileTemplate: + name: spec_file_small + path_template: "{catalogs_dir}/som/{project}_spec_data_small.hdf5" + + +# The next plots list all available algorithms of various types and assigns short names each of then +# + +# These describe all the algorithms that emulate spectroscopic selections +SpecSelections: + # - SpecSelection: + # name: GAMA: + # Select: SpecSelection_GAMA + # Module: rail.creation.degraders.spectroscopic_selections + # - SpecSelection: + # name: BOSS + # Select: SpecSelection_BOSS + # Module: rail.creation.degraders.spectroscopic_selections + # - SpecSelection: + # name: VVDSf02 + # Select: SpecSelection_VVDSf02 + # Module: rail.creation.degraders.spectroscopic_selections + # - SpecSelection: + # name: HSC + # Select: SpecSelection_HSC + # Module: rail.creation.degraders.spectroscopic_selections + - SpecSelection: + name: zCOSMOS + Select: SpecSelection_zCOSMOS + Module: rail.creation.degraders.spectroscopic_selections + + +# These describe all the algorithms that estimate PZ +PZAlgorithms: + - PZAlgorithm: + name: trainz + Estimate: TrainZEstimator + Inform: TrainZInformer + Module: rail.estimation.algos.train_z + - PZAlgorithm: + name: simplenn + Estimate: SklNeurNetEstimator + Inform: SklNeurNetInformer + Module: rail.estimation.algos.sklearn_neurnet + - PZAlgorithm: + name: fzboost + Estimate: FlexZBoostEstimator + Inform: FlexZBoostInformer + Module: rail.estimation.algos.flexzboost + - PZAlgorithm: + name: knn + Estimate: KNearNeighEstimator + Inform: KNearNeighInformer + Module: rail.estimation.algos.k_nearneigh + - PZAlgorithm: + name: gpz + Estimate: GPzEstimator + Inform: GPzInformer + Module: rail.estimation.algos.gpz + + +# These describe all the algorithms that classify objects into tomographic bins +Classifiers: + - Classifier: + name: equal_count + Classify: EqualCountClassifier + Module: rail.estimation.algos.equal_count + - Classifier: + name: uniform_binning + Classify: UniformBinningClassifier + Module: rail.estimation.algos.uniform_binning + + +# These describe all the algorithms that summarize PZ information into NZ distributions +Summarizers: + - Summarizer: + name: naive_stack + Summarize: NaiveStackMaskedSummarizer + Module: rail.estimation.algos.naive_stack + - Summarizer: + name: point_est_hist + Summarize: PointEstHistMaskedSummarizer + Module: rail.estimation.algos.point_est_hist + + +# These describe the error models we use in the truth_to_observed pipeline +ErrorModels: + - ErrorModel: + name: lsst + ErrorModel: LSSTErrorModel + Module: rail.creation.degraders.photometric_errors + - ErrorModel: + name: roman + ErrorModel: RomanErrorModel + Module: rail.creation.degraders.photometric_errors + + +# These describe the ways we can sub-sample the data +Subsamplers: + - Subsampler: + name: random_subsampler + Subsample: RandomSubsampler + Module: rail.projects.subsampler + - Subsampler: + name: multi_catalog_subsampler + Subsample: MultiCatalogSubsample + Module: rail.projects.subsampler + + +# These describe the ways we can reduce the data +Reducers: + - Reducer: + name: roman_rubin + Reduce: RomanRubinReducer + Module: rail.projects.reducer + + - Reducer: + name: flagship + Reduce: FlagshipReducer + Module: rail.projects.reducer + + - Reducer: + name: cardinal + Reduce: CardinalReducer + Module: rail.projects.reducer + + +# These describe the various data analysis pipelines +Pipelines: + - PipelineTemplate: + name: truth_to_observed + pipeline_class: rail.pipelines.degradation.truth_to_observed.TruthToObservedPipeline + input_catalog_template: reduced + output_catalog_template: degraded + kwargs: + error_models: ['all'] + selectors: ['all'] + blending: true + - PipelineTemplate: + name: prepare + pipeline_class: rail.pipelines.utils.prepare_observed.PrepareObservedPipeline + input_catalog_template: reduced + output_catalog_template: degraded + - PipelineTemplate: + name: photometric_errors + pipeline_class: rail.pipelines.degradation.apply_phot_errors.ApplyPhotErrorsPipeline + input_catalog_template: reduced + output_catalog_template: degraded + kwargs: + error_models: ['all'] + - PipelineTemplate: + name: blending + input_catalog_template: degraded + output_catalog_template: degraded + pipeline_class: rail.pipelines.degradation.blending.BlendingPipeline + kwargs: {} + - PipelineTemplate: + name: spec_selection + input_catalog_template: degraded + output_catalog_template: degraded + input_catalog_basename: output_dereddener_errors.pq + pipeline_class: rail.pipelines.degradation.spectroscopic_selection_pipeline.SpectroscopicSelectionPipeline + kwargs: + selectors: ['all'] + - PipelineTemplate: + name: inform + pipeline_class: rail.pipelines.estimation.inform_all.InformPipeline + input_catalog_template: degraded + output_catalog_template: degraded + input_file_templates: + input: + flavor: baseline + tag: train + kwargs: + algorithms: ['all'] + - PipelineTemplate: + name: estimate + pipeline_class: rail.pipelines.estimation.estimate_all.EstimatePipeline + input_catalog_template: degraded + output_catalog_template: degraded + input_file_templates: + input: + flavor: baseline + tag: test + kwargs: + algorithms: ['all'] + - PipelineTemplate: + name: evaluate + pipeline_class: rail.pipelines.evaluation.evaluate_all.EvaluationPipeline + input_catalog_template: degraded + output_catalog_template: degraded + input_file_templates: + truth: + flavor: baseline + tag: test + kwargs: + algorithms: ['all'] + - PipelineTemplate: + name: pz + pipeline_class: rail.pipelines.estimation.pz_all.PzPipeline + input_catalog_template: degraded + output_catalog_template: degraded + input_file_templates: + input_train: + flavor: baseline + tag: train + input_test: + flavor: baseline + tag: test + kwargs: + algorithms: ['all'] + - PipelineTemplate: + name: inform_sompz + pipeline_class: rail.pipelines.estimation.inform_sompz.InformSomPZPipeline + input_file_templates: + input_deep_data: + flavor: baseline + tag: deep + input_wide_data: + flavor: baseline + tag: wide + kwargs: + wide_catalog_tag: SompzWideTestCatalogConfig + deep_catalog_tag: SompzDeepTestCatalogConfig + catalog_module: rail.sompz.utils + - PipelineTemplate: + name: estimate_sompz + pipeline_class: rail.pipelines.estimation.estimate_sompz.EstimateSomPZPipeline + input_file_templates: + input_deep: + flavor: baseline + tag: deep + input_wide: + flavor: baseline + tag: wide + input_spec: + flavor: baseline + tag: spec + kwargs: + wide_catalog_tag: SompzWideTestCatalogConfig + catalog_module: rail.sompz.utils + deep_catalog_tag: SompzDeepTestCatalogConfig + - PipelineTemplate: + name: inform_somlike + pipeline_class: rail.pipelines.calib.inform_somlike.InformSomlikePipeline + input_file_templates: + input_spec_data: + flavor: baseline + tag: spec + kwargs: + algorithms: ['all'] + wide_catalog_tag: SompzWideTestCatalogConfig + deep_catalog_tag: SompzDeepTestCatalogConfig + catalog_module: rail.sompz.utils + - PipelineTemplate: + name: somlike_recalib + pipeline_class: rail.pipelines.calib.somlike_recalib.SomlikeRecalibPipeline + input_file_templates: + input_deep: + flavor: baseline + tag: deep + input_wide: + flavor: baseline + tag: wide + input_spec: + flavor: baseline + tag: spec + kwargs: + algorithms: ['all'] + assign_algos: null + wide_catalog_tag: SompzWideTestCatalogConfig + catalog_module: rail.sompz.utils + deep_catalog_tag: SompzDeepTestCatalogConfig + - PipelineTemplate: + name: inform_recalib + pipeline_class: rail.pipelines.calib.inform_recalib.InformRecalibPipeline + input_file_templates: + truth: + flavor: baseline + tag: test + kwargs: + algorithms: ['all'] + recalib_algos: null + - PipelineTemplate: + name: estimate_recalib + pipeline_class: rail.pipelines.calib.estimate_recalib.EstimateRecalibPipeline + input_file_templates: + input: + flavor: baseline + tag: test + kwargs: + algorithms: ['all'] + recalib_algos: null + - PipelineTemplate: + name: tomography + pipeline_class: rail.pipelines.estimation.tomography.TomographyPipeline + input_catalog_template: degraded + output_catalog_template: degraded + input_file_templates: + truth: + flavor: baseline + tag: test + kwargs: + algorithms: ['all'] + classifiers: ['all'] + summarizers: ['all'] + n_tomo_bins: 5 + + +# These describe the selections going from "truth" to "reduced" catalog + +# These just all use different limiting i-band magnitudes +Selections: + - Selection: + name: maglim_25.5 + cuts: + maglim_i: [null, 25.5] + - Selection: + name: gold + cuts: + maglim_i: [null, 25.5] + - Selection: + name: blend + cuts: + maglim_i: [null, 26.0] + - Selection: + name: crap + cuts: + maglim_i: [null, 30.0] + - Selection: + name: all + cuts: + maglim_i: [null, null] + +# These describe the subsampling used to make test and training datasets +Subsamples: + # Testing subsample with 100k events + - Subsample: + name: test_100k + seed: 1234 + num_objects: 100000 + # Training subsample with 100k events, and a different seed to select the events + - Subsample: + name: train_100k + seed: 4321 + num_objects: 100000 + # Training subsample with 100k events, and a different seed to select the events + - Subsample: + name: train_10 + seed: 5555 + num_objects: 100000 + - Subsample: + name: multi_catalog + seed: 5555 + num_objects: 1000 + weight_map: "tests/dummy_weight_map.fits" + cuts: # data selection cuts + - ['ra', '>', 45] + - ['ra', '<', 47] + - ['dec', '>', 101] + - ['dec', '<', 102] + inputs: # All the inputs + rubin: # rubin input config + basename: output_lsst_wfd_1yr.pq # file to look for + bands: ['u', 'g', 'r', 'i', 'z', 'y'] # bands to consider + mag_band_name_template: "{band}_cModelMag" # template for columns + mag_err_band_name_template: "{band}_cModelMagErr" # template for columns + extra_cols: [] # extra columns to copy + cuts: + - ['i_cModelMag', '<', 25] + roman: + basename: output_roman_medium.pq + bands: ['Y106', 'J129', 'H158'] + mag_band_name_template: "ROMAN_obs_{band}" + mag_err_band_name_template: "ROMAN_obs_{band}_err" + extra_cols: [] + euclid: + basename: output_euclid_3band.pq + bands: ['Y', 'J', 'H'] + mag_band_name_template: "euclid_{band}_unifMag" + mag_err_band_name_template: "euclid_{band}_unifMagErr" + extra_cols: [] + +# These describe the ways we can split the data +Splitters: + - Splitter: + name: random_splitter + Split: RandomSplitter + Module: rail.projects.splitter diff --git a/tests/ci_project-cardinal.yaml b/tests/ci_project-cardinal.yaml new file mode 100644 index 0000000..f4d5907 --- /dev/null +++ b/tests/ci_project-cardinal.yaml @@ -0,0 +1,54 @@ +Project: + + Name: ci_test_cardinal + + # Include other configuration files + Includes: + - tests/ci_cardinal_project_library.yaml + + PathTemplates: {} + + CommonPaths: + root: /Users/sam/TMP/arrowtmp/rail_projects/examples/DATA/ + scratch_root: "{root}" + catalogs_dir: "{root}/CARDINAL" + project: ci_test_cardinal + sim_version: v1 + + # Baseline configuraiton, included in others by default + Baseline: + catalog_tag: cardinal + pipelines: ['all'] + file_aliases: # Set the training and test files + test: test_file_100k + train: train_file_100k + train_zCOSMOS: train_file_zCOSMOS_100k + wide: wide_file_full + deep: deep_file_full + spec: spec_file_full + + # These define the variant configurations for the various parts of the analysis + Flavors: + - Flavor: + name: train_cosmos + pipelines: ['pz', 'tomography'] + file_aliases: # Set the training and test files + test: test_file_100k + train: train_file_zCOSMOS_100k + - Flavor: + name: gpz_gl + pipelines: ['pz'] # only run the pz pipeline + pipeline_overrides: # Override specifics for particular pipelines + default: + kwargs: + algorithms: ['gpz'] # Only run gpz + inform: + inform_gpz: + gpz_method: GL + + # These are variables that we iterate over when running over entire catalogs + IterationVars: + healpix: + - 430 + - 73 + - 122 From 613921a94da0c369b81240570e3178d7283e3508 Mon Sep 17 00:00:00 2001 From: sschmidt23 Date: Wed, 28 Jan 2026 16:10:28 -0800 Subject: [PATCH 03/11] examples yaml --- examples/ci_project-cardinal.yaml | 55 +++++++++++++++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 examples/ci_project-cardinal.yaml diff --git a/examples/ci_project-cardinal.yaml b/examples/ci_project-cardinal.yaml new file mode 100644 index 0000000..6635529 --- /dev/null +++ b/examples/ci_project-cardinal.yaml @@ -0,0 +1,55 @@ +Project: + + Name: ci_test_cardinal + + # Include other configuration files + Includes: + - tests/ci_cardinal_project_library.yaml + + PathTemplates: {} + + CommonPaths: + root: /Users/sam/TMP/arrowtmp/rail_projects/examples/DATA + scratch_root: "{root}" + catalogs_dir: "{root}/CARDINAL" + project: ci_test_cardinal + sim_version: v1 + + # Baseline configuraiton, included in others by default + Baseline: + catalog_tag: cardinal + pipelines: ['all'] + file_aliases: # Set the training and test files + test: test_file_100k + train: train_file_100k + train_zCOSMOS: train_file_zCOSMOS_100k + wide: wide_file_full + deep: deep_file_full + spec: spec_file_full + + # These define the variant configurations for the various parts of the analysis + Flavors: + - Flavor: + name: train_cosmos + pipelines: ['pz', 'tomography'] + file_aliases: # Set the training and test files + test: test_file_100k + train: train_file_zCOSMOS_100k + - Flavor: + name: gpz_gl + pipelines: ['pz'] # only run the pz pipeline + pipeline_overrides: # Override specifics for particular pipelines + default: + kwargs: + algorithms: ['gpz'] # Only run gpz + inform: + inform_gpz: + gpz_method: GL + + # These are variables that we iterate over when running over entire catalogs + IterationVars: + healpix: + - 430 + - 73 + - 122 + - 99 From d48a7672c38295d56cd3d0a4e436b1f0028f066d Mon Sep 17 00:00:00 2001 From: Sam Schmidt Date: Wed, 28 Jan 2026 16:51:22 -0800 Subject: [PATCH 04/11] update paths --- examples/ci_project-cardinal.yaml | 4 ++-- tests/ci_cardinal_project_library.yaml | 4 ++-- tests/ci_project-cardinal.yaml | 13 +++++++------ 3 files changed, 11 insertions(+), 10 deletions(-) diff --git a/examples/ci_project-cardinal.yaml b/examples/ci_project-cardinal.yaml index 6635529..9866182 100644 --- a/examples/ci_project-cardinal.yaml +++ b/examples/ci_project-cardinal.yaml @@ -9,9 +9,9 @@ Project: PathTemplates: {} CommonPaths: - root: /Users/sam/TMP/arrowtmp/rail_projects/examples/DATA + root: /global/cfs/cdirs/lsst/groups/PZ/Cardinal scratch_root: "{root}" - catalogs_dir: "{root}/CARDINAL" + catalogs_dir: "{root}/parquet_files" project: ci_test_cardinal sim_version: v1 diff --git a/tests/ci_cardinal_project_library.yaml b/tests/ci_cardinal_project_library.yaml index 6a6f2da..0a61ffa 100644 --- a/tests/ci_cardinal_project_library.yaml +++ b/tests/ci_cardinal_project_library.yaml @@ -14,12 +14,12 @@ Catalogs: # The input "Truth" catalog - CatalogTemplate: name: truth - path_template: "{catalogs_dir}/Chinchilla-3-triofile.{healpix}.1pct.parquet" + path_template: "{catalogs_dir}/Chinchilla-3-triofile.{healpix}.parquet" iteration_vars: ['healpix'] # Catalogs that have been reduced using a particular selection - CatalogTemplate: name: reduced - path_template: "{catalogs_dir}/{project}_{selection}/{healpix}/Chinchilla-3-triofile.1pct.pq" + path_template: "{catalogs_dir}/{project}_{selection}/{healpix}/Chinchilla-3-triofile.pq" iteration_vars: ['healpix'] # Data output from running some degraders on the original catalog # Note that the {basename} can be used to select which degraded output we want diff --git a/tests/ci_project-cardinal.yaml b/tests/ci_project-cardinal.yaml index f4d5907..8a2bc23 100644 --- a/tests/ci_project-cardinal.yaml +++ b/tests/ci_project-cardinal.yaml @@ -9,9 +9,9 @@ Project: PathTemplates: {} CommonPaths: - root: /Users/sam/TMP/arrowtmp/rail_projects/examples/DATA/ + root: /global/cfs/cdirs/lsst/groups/PZ/Cardinal scratch_root: "{root}" - catalogs_dir: "{root}/CARDINAL" + catalogs_dir: "{root}/parquet_files" project: ci_test_cardinal sim_version: v1 @@ -30,17 +30,17 @@ Project: # These define the variant configurations for the various parts of the analysis Flavors: - Flavor: - name: train_cosmos + name: train_cosmo pipelines: ['pz', 'tomography'] file_aliases: # Set the training and test files test: test_file_100k train: train_file_zCOSMOS_100k - - Flavor: + - Flavor name: gpz_gl pipelines: ['pz'] # only run the pz pipeline - pipeline_overrides: # Override specifics for particular pipelines + pipeline_overrids: # Override specifics for particular pipelines default: - kwargs: + kwargs algorithms: ['gpz'] # Only run gpz inform: inform_gpz: @@ -52,3 +52,4 @@ Project: - 430 - 73 - 122 + - 99 From d5b26dc860e126c2dca020700c34afaf1bef4ef4 Mon Sep 17 00:00:00 2001 From: Sam Schmidt Date: Wed, 28 Jan 2026 22:54:41 -0800 Subject: [PATCH 05/11] add a few more pixels --- examples/ci_project-cardinal.yaml | 4 ++++ tests/ci_project-cardinal.yaml | 4 ++++ 2 files changed, 8 insertions(+) diff --git a/examples/ci_project-cardinal.yaml b/examples/ci_project-cardinal.yaml index 9866182..41696f7 100644 --- a/examples/ci_project-cardinal.yaml +++ b/examples/ci_project-cardinal.yaml @@ -53,3 +53,7 @@ Project: - 73 - 122 - 99 + - 16 + - 58 + - 277 + - 346 diff --git a/tests/ci_project-cardinal.yaml b/tests/ci_project-cardinal.yaml index 8a2bc23..8626729 100644 --- a/tests/ci_project-cardinal.yaml +++ b/tests/ci_project-cardinal.yaml @@ -53,3 +53,7 @@ Project: - 73 - 122 - 99 + - 16 + - 58 + - 277 + - 346 From ad814df23f314a9ca358e1ed88f2186bfb88422d Mon Sep 17 00:00:00 2001 From: Sam Schmidt Date: Fri, 6 Feb 2026 12:57:52 -0800 Subject: [PATCH 06/11] add wise and redshift cols, switch to lensed mags --- src/rail/projects/reducer.py | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/rail/projects/reducer.py b/src/rail/projects/reducer.py index ab716ef..70fb8a5 100644 --- a/src/rail/projects/reducer.py +++ b/src/rail/projects/reducer.py @@ -105,7 +105,11 @@ "Roman_H158", "Roman_F184", "Roman_K213", + "WISE_W1", + "WISE_W2", "redshift", + "true_redshift", + "t_true_redshift", "Euclid_Y", "Euclid_J", "Euclid_H", From 22b5714595441b14ee0415862ab15a63c2564ede Mon Sep 17 00:00:00 2001 From: Sam Schmidt Date: Tue, 10 Feb 2026 14:07:03 -0800 Subject: [PATCH 07/11] add test, update nb, switch ci download to nersc --- examples/cardinal_project.yaml | 59 +++++ examples/cardinal_project_library.yaml | 292 ++++++++++++++++++++++++ examples/ci_project-cardinal.yaml | 2 +- examples/rail_project_example.ipynb | 91 +++++++- src/rail/projects/library.py | 3 +- tests/ci_cardinal_project.yaml | 49 ++++ tests/ci_cardinal_project_library.yaml | 202 ++-------------- tests/projects/test_cardinal_project.py | 190 +++++++++++++++ 8 files changed, 692 insertions(+), 196 deletions(-) create mode 100644 examples/cardinal_project.yaml create mode 100644 examples/cardinal_project_library.yaml create mode 100644 tests/ci_cardinal_project.yaml create mode 100644 tests/projects/test_cardinal_project.py diff --git a/examples/cardinal_project.yaml b/examples/cardinal_project.yaml new file mode 100644 index 0000000..5277061 --- /dev/null +++ b/examples/cardinal_project.yaml @@ -0,0 +1,59 @@ +Project: + + Name: test_cardinal + + # Include other configuration files + Includes: + - examples/cardinal_project_library.yaml + + PathTemplates: {} + + CommonPaths: + root: /global/cfs/cdirs/lsst/groups/PZ/Cardinal + scratch_root: "{root}" + catalogs_dir: "{root}/parquet_files" + project: test_cardinal + sim_version: v1 + + # Baseline configuraiton, included in others by default + Baseline: + catalog_tag: cardinal + pipelines: ['all'] + file_aliases: # Set the training and test files + test: test_file_100k + train: train_file_100k + train_zCOSMOS: train_file_zCOSMOS_100k + wide: wide_file_full + deep: deep_file_full + spec: spec_file_full + + # These define the variant configurations for the various parts of the analysis + Flavors: + - Flavor: + name: train_cosmos + pipelines: ['pz', 'tomography'] + file_aliases: # Set the training and test files + test: test_file_100k + train: train_file_zCOSMOS_100k + - Flavor: + name: gpz_gl + pipelines: ['pz'] # only run the pz pipeline + pipeline_overrides: # Override specifics for particular pipelines + default: + kwargs: + algorithms: ['gpz'] # Only run gpz + inform: + inform_gpz: + gpz_method: GL + + # These are variables that we iterate over when running over entire catalogs + IterationVars: + healpix: + - 430 + - 73 + - 122 + - 99 + - 16 + - 58 + - 277 + - 346 diff --git a/examples/cardinal_project_library.yaml b/examples/cardinal_project_library.yaml new file mode 100644 index 0000000..bb2f34c --- /dev/null +++ b/examples/cardinal_project_library.yaml @@ -0,0 +1,292 @@ +# This is the "library" of common defintions shared between similar projects + +# Templates we use to define catalogs +# +# A CatalogTemplate can be given several interpolants to resolve to a specific Catalog +# +# Some of the interpolants [{catalogs_dir}, {project}, {sim_version}] +# are defined in the Project CommonPaths block +# +# Possibles values of {selection} are defined the the library "Selections" block +# +# Possible values of {flavor} are defined the the Project "Flavors" block +Catalogs: + # The input "Truth" catalog + - CatalogTemplate: + name: truth + path_template: "{catalogs_dir}/Chinchilla-3-triofile.{healpix}.parquet" + iteration_vars: ['healpix'] + # Catalogs that have been reduced using a particular selection + - CatalogTemplate: + name: reduced + path_template: "{catalogs_dir}/{project}_{selection}/{healpix}/Chinchilla-3-triofile.pq" + iteration_vars: ['healpix'] + # Data output from running some degraders on the original catalog + # Note that the {basename} can be used to select which degraded output we want + - CatalogTemplate: + name: degraded + path_template: "{catalogs_dir}/{project}_{selection}_{flavor}/{healpix}/{basename}" + iteration_vars: ['healpix'] + + +# This file describes the templates we use to define files and specfic instances +# of files +# +# A FileTemplate can be given several interpolants to resolve to a specific FileInstance +# +# Some of the interpolants [{catalogs_dir}, {project}] +# are defined in the Project CommonPaths block +# +# Possibles values of {selection} are defined the the library "Selections" block +Files: + # Testing data file + - FileTemplate: + name: test_file_100k + path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_100k.hdf5" + # Generic training data file + - FileTemplate: + name: train_file_100k + path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_100k.hdf5" + - FileTemplate: + name: train_file_200k + path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_200k.hdf5" + - FileTemplate: + name: train_file_10 + path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_10.hdf5" + - FileTemplate: + name: test_split_file + path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_split_test_10.hdf5" + - FileTemplate: + name: train_split_file + path_template: "{catalogs_dir}/train/{project}_{selection}_baseline_split_train_10.hdf5" + - FileTemplate: + name: deep_file_full + path_template: "{catalogs_dir}/som/{project}_deep_data_full.hdf5" + - FileTemplate: + name: deep_file_small + path_template: "{catalogs_dir}/som/{project}_deep_data_small.hdf5" + - FileTemplate: + name: wide_file_full + path_template: "{catalogs_dir}/som/{project}_wide_data_full.hdf5" + - FileTemplate: + name: wide_file_small + path_template: "{catalogs_dir}/som/{project}_wide_data_small.hdf5" + - FileTemplate: + name: spec_file_full + path_template: "{catalogs_dir}/som/{project}_spec_data_full.hdf5" + - FileTemplate: + name: spec_file_small + path_template: "{catalogs_dir}/som/{project}_spec_data_small.hdf5" + + +# The next plots list all available algorithms of various types and assigns short names each of then +# + +# These describe all the algorithms that emulate spectroscopic selections +SpecSelections: + - SpecSelection: + name: zCOSMOS + Select: SpecSelection_zCOSMOS + Module: rail.creation.degraders.spectroscopic_selections + + +# These describe all the algorithms that estimate PZ +PZAlgorithms: + - PZAlgorithm: + name: trainz + Estimate: TrainZEstimator + Inform: TrainZInformer + Module: rail.estimation.algos.train_z + - PZAlgorithm: + name: simplenn + Estimate: SklNeurNetEstimator + Inform: SklNeurNetInformer + Module: rail.estimation.algos.sklearn_neurnet + - PZAlgorithm: + name: fzboost + Estimate: FlexZBoostEstimator + Inform: FlexZBoostInformer + Module: rail.estimation.algos.flexzboost + - PZAlgorithm: + name: knn + Estimate: KNearNeighEstimator + Inform: KNearNeighInformer + Module: rail.estimation.algos.k_nearneigh + - PZAlgorithm: + name: gpz + Estimate: GPzEstimator + Inform: GPzInformer + Module: rail.estimation.algos.gpz + + +# These describe all the algorithms that classify objects into tomographic bins +Classifiers: + - Classifier: + name: equal_count + Classify: EqualCountClassifier + Module: rail.estimation.algos.equal_count + - Classifier: + name: uniform_binning + Classify: UniformBinningClassifier + Module: rail.estimation.algos.uniform_binning + + +# These describe the error models we use in the truth_to_observed pipeline +ErrorModels: + - ErrorModel: + name: lsst + ErrorModel: LSSTErrorModel + Module: rail.creation.degraders.photometric_errors + - ErrorModel: + name: roman + ErrorModel: RomanErrorModel + Module: rail.creation.degraders.photometric_errors + + +# These describe the ways we can sub-sample the data +Subsamplers: + - Subsampler: + name: random_subsampler + Subsample: RandomSubsampler + Module: rail.projects.subsampler + - Subsampler: + name: multi_catalog_subsampler + Subsample: MultiCatalogSubsample + Module: rail.projects.subsampler + + +# These describe the ways we can reduce the data +Reducers: + - Reducer: + name: cardinal + Reduce: CardinalReducer + Module: rail.projects.reducer + + +# These describe the various data analysis pipelines +Pipelines: + - PipelineTemplate: + name: truth_to_observed + pipeline_class: rail.pipelines.degradation.truth_to_observed.TruthToObservedPipeline + input_catalog_template: reduced + output_catalog_template: degraded + kwargs: + error_models: ['all'] + selectors: ['all'] + blending: true + - PipelineTemplate: + name: prepare + pipeline_class: rail.pipelines.utils.prepare_observed.PrepareObservedPipeline + input_catalog_template: reduced + output_catalog_template: degraded + - PipelineTemplate: + name: photometric_errors + pipeline_class: rail.pipelines.degradation.apply_phot_errors.ApplyPhotErrorsPipeline + input_catalog_template: reduced + output_catalog_template: degraded + kwargs: + error_models: ['all'] + - PipelineTemplate: + name: spec_selection + input_catalog_template: degraded + output_catalog_template: degraded + input_catalog_basename: output_dereddener_errors.pq + pipeline_class: rail.pipelines.degradation.spectroscopic_selection_pipeline.SpectroscopicSelectionPipeline + kwargs: + selectors: ['all'] + - PipelineTemplate: + name: inform + pipeline_class: rail.pipelines.estimation.inform_all.InformPipeline + input_catalog_template: degraded + output_catalog_template: degraded + input_file_templates: + input: + flavor: baseline + tag: train + kwargs: + algorithms: ['all'] + - PipelineTemplate: + name: estimate + pipeline_class: rail.pipelines.estimation.estimate_all.EstimatePipeline + input_catalog_template: degraded + output_catalog_template: degraded + input_file_templates: + input: + flavor: baseline + tag: test + kwargs: + algorithms: ['all'] + - PipelineTemplate: + name: evaluate + pipeline_class: rail.pipelines.evaluation.evaluate_all.EvaluationPipeline + input_catalog_template: degraded + output_catalog_template: degraded + input_file_templates: + truth: + flavor: baseline + tag: test + kwargs: + algorithms: ['all'] + - PipelineTemplate: + name: pz + pipeline_class: rail.pipelines.estimation.pz_all.PzPipeline + input_catalog_template: degraded + output_catalog_template: degraded + input_file_templates: + input_train: + flavor: baseline + tag: train + input_test: + flavor: baseline + tag: test + kwargs: + algorithms: ['all'] +# These describe the selections going from "truth" to "reduced" catalog + +# These just all use different limiting i-band magnitudes +Selections: + - Selection: + name: maglim_25.5 + cuts: + maglim_i: [null, 25.5] + - Selection: + name: gold + cuts: + maglim_i: [null, 25.5] + - Selection: + name: blend + cuts: + maglim_i: [null, 26.0] + - Selection: + name: crap + cuts: + maglim_i: [null, 30.0] + - Selection: + name: all + cuts: + maglim_i: [null, null] + +# These describe the subsampling used to make test and training datasets +Subsamples: + # Testing subsample with 100 events + - Subsample: + name: test_100k + seed: 1234 + num_objects: 100000 + # Training subsample with 100k events, and a different seed to select the events + - Subsample: + name: train_100k + seed: 4321 + num_objects: 100000 + # Training subsample with 100k events, and a different seed to select the events + - Subsample: + name: train_200k + seed: 5555 + num_objects: 200000 + +# These describe the ways we can split the data +Splitters: + - Splitter: + name: random_splitter + Split: RandomSplitter + Module: rail.projects.splitter diff --git a/examples/ci_project-cardinal.yaml b/examples/ci_project-cardinal.yaml index 41696f7..6b4fed8 100644 --- a/examples/ci_project-cardinal.yaml +++ b/examples/ci_project-cardinal.yaml @@ -4,7 +4,7 @@ Project: # Include other configuration files Includes: - - tests/ci_cardinal_project_library.yaml + - examples/ci_cardinal_project_library.yaml PathTemplates: {} diff --git a/examples/rail_project_example.ipynb b/examples/rail_project_example.ipynb index e644d4b..8ddae36 100644 --- a/examples/rail_project_example.ipynb +++ b/examples/rail_project_example.ipynb @@ -20,10 +20,77 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "96bee599-4711-4a07-b182-1cbe257ea4d8", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "temp_data/\n", + "temp_data/data/\n", + "temp_data/data/ci_test_v1.1.3/\n", + "temp_data/data/ci_test_v1.1.3/9924/\n", + "temp_data/data/ci_test_v1.1.3/9924/part-0.parquet\n", + "temp_data/data/ci_test_v1.1.3/9925/\n", + "temp_data/data/ci_test_v1.1.3/9925/part-0.parquet\n", + "temp_data/projects/\n", + "temp_data/projects/ci_test/\n", + "temp_data/projects/ci_test/data/\n", + "temp_data/projects/ci_test/data/blend_baseline/\n", + "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_equal_count_bin2.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin3_point_est_hist.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_estimate_trainz.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin2_naive_stack.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin0_naive_stack.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin1_naive_stack.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin2_naive_stack.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_uniform_binning_bin3.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_evaluate_fzboost.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_uniform_binning_bin4.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_equal_count_bin1.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin4_point_est_hist.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/model_inform_simplenn.pkl\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin0_point_est_hist.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_equal_count_bin3.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin4_naive_stack.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin1_point_est_hist.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin3_naive_stack.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin1_point_est_hist.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin1_naive_stack.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_estimate_knn.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin4_point_est_hist.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin0_point_est_hist.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_evaluate_knn.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_evaluate_trainz.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/model_inform_gpz.pkl\n", + "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_uniform_binning_bin1.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_uniform_binning_bin2.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_estimate_gpz.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_estimate_fzboost.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_estimate_bpz.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_uniform_binning_bin0.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin4_naive_stack.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin2_point_est_hist.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/model_inform_sompz.pkl\n", + "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_equal_count_bin0.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_equal_count_bin4.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_estimate_simplenn.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin2_point_est_hist.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin3_naive_stack.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_evaluate_simplenn.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin0_naive_stack.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin3_point_est_hist.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/output_evaluate_gpz.hdf5\n", + "temp_data/projects/ci_test/data/blend_baseline/model_inform_knn.pkl\n", + "temp_data/projects/ci_test/data/blend_baseline/model_inform_fzboost.pkl\n", + "temp_data/projects/ci_test/data/blend_baseline/model_inform_bpz.pkl\n", + "temp_data/projects/ci_test/data/blend_baseline/model_inform_train_z.pkl\n", + "temp_data/projects/ci_test/data/blend_baseline/model_inform_trainz.pkl\n" + ] + } + ], "source": [ "import os\n", "from rail.projects import library\n", @@ -49,7 +116,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "7136e23a-43f1-4a36-ba77-03b9a649c449", "metadata": {}, "outputs": [], @@ -69,10 +136,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "f47f06c0-2718-4cdd-aaa9-156341336907", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['tests/temp_data/data/ci_test_v1.1.3/9924/part-0.parquet', 'tests/temp_data/data/ci_test_v1.1.3/9925/part-0.parquet']\n" + ] + } + ], "source": [ "catalog_files_truth = project.get_catalog_files(\"truth\")\n", "print(catalog_files_truth)" @@ -215,9 +290,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "testenv", "language": "python", - "name": "python3" + "name": "testenv" }, "language_info": { "codemirror_mode": { @@ -229,7 +304,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.4" + "version": "3.12.12" } }, "nbformat": 4, diff --git a/src/rail/projects/library.py b/src/rail/projects/library.py index 4ab108d..f2dcb90 100644 --- a/src/rail/projects/library.py +++ b/src/rail/projects/library.py @@ -236,7 +236,8 @@ def setup_project_area() -> int: # pragma: no cover if not os.path.exists("tests/ci_test.tgz"): urllib.request.urlretrieve( - "http://s3df.slac.stanford.edu/people/echarles/xfer/ci_test.tgz", + "https://portal.nersc.gov/cfs/lsst/PZ/test_data/ci_test.tgz", + # "http://s3df.slac.stanford.edu/people/echarles/xfer/ci_test.tgz", "tests/ci_test.tgz", ) if not os.path.exists("tests/ci_test.tgz"): diff --git a/tests/ci_cardinal_project.yaml b/tests/ci_cardinal_project.yaml new file mode 100644 index 0000000..046ddf2 --- /dev/null +++ b/tests/ci_cardinal_project.yaml @@ -0,0 +1,49 @@ +Project: + + Name: ci_test + + # Include other configuration files + Includes: + - tests/ci_cardinal_project_library.yaml + + PathTemplates: {} + + CommonPaths: + root: tests/temp_data + scratch_root: "{root}" + catalogs_dir: "{root}/data/ci_test_v1.1.3" + project: ci_test + sim_version: v1.1.3 + + # Baseline configuraiton, included in others by default + Baseline: + catalog_tag: roman_rubin + pipelines: ['all'] + file_aliases: # Set the training and test files + test: test_100 + train: train_100 + + # These define the variant configurations for the various parts of the analysis + Flavors: + - Flavor: + name: train_cosmos + pipelines: ['pz', 'tomography'] + file_aliases: # Set the training and test files + test: test_100 + train: train_100 + - Flavor: + name: gpz_gl + pipelines: ['pz'] # only run the pz pipeline + pipeline_overrides: # Override specifics for particular pipelines + default: + kwargs: + algorithms: ['gpz'] # Only run gpz + inform: + inform_gpz: + gpz_method: GL + + # These are variables that we iterate over when running over entire catalogs + IterationVars: + healpix: + - 122 + - 58 diff --git a/tests/ci_cardinal_project_library.yaml b/tests/ci_cardinal_project_library.yaml index 0a61ffa..dd70c89 100644 --- a/tests/ci_cardinal_project_library.yaml +++ b/tests/ci_cardinal_project_library.yaml @@ -14,12 +14,12 @@ Catalogs: # The input "Truth" catalog - CatalogTemplate: name: truth - path_template: "{catalogs_dir}/Chinchilla-3-triofile.{healpix}.parquet" + path_template: "{catalogs_dir}/{healpix}/cardinal_test-0.parquet" iteration_vars: ['healpix'] # Catalogs that have been reduced using a particular selection - CatalogTemplate: name: reduced - path_template: "{catalogs_dir}/{project}_{selection}/{healpix}/Chinchilla-3-triofile.pq" + path_template: "{catalogs_dir}/{project}_{selection}/{healpix}/cardinal_test_file-0.pq" iteration_vars: ['healpix'] # Data output from running some degraders on the original catalog # Note that the {basename} can be used to select which degraded output we want @@ -41,15 +41,18 @@ Catalogs: Files: # Testing data file - FileTemplate: - name: test_file_100k + name: test_100 path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_100k.hdf5" # Generic training data file - FileTemplate: - name: train_file_100k + name: train_100 path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_100k.hdf5" - # Training file with a non-representative sample from the zCOSMOS selection - FileTemplate: - name: train_file_zCOSMOS_100k + name: train_file_02k + path_template: "{catalogs_dir}/test/{project}_{selection}_baseline_200k.hdf5" +# Training file with a non-representative sample from the zCOSMOS selection + - FileTemplate: + name: train_file_zCOSMOS_01k path_template: "{catalogs_dir}/train/{project}_{selection}_zCOSMOS_100k.hdf5" # Small trainng file - FileTemplate: @@ -86,22 +89,6 @@ Files: # These describe all the algorithms that emulate spectroscopic selections SpecSelections: - # - SpecSelection: - # name: GAMA: - # Select: SpecSelection_GAMA - # Module: rail.creation.degraders.spectroscopic_selections - # - SpecSelection: - # name: BOSS - # Select: SpecSelection_BOSS - # Module: rail.creation.degraders.spectroscopic_selections - # - SpecSelection: - # name: VVDSf02 - # Select: SpecSelection_VVDSf02 - # Module: rail.creation.degraders.spectroscopic_selections - # - SpecSelection: - # name: HSC - # Select: SpecSelection_HSC - # Module: rail.creation.degraders.spectroscopic_selections - SpecSelection: name: zCOSMOS Select: SpecSelection_zCOSMOS @@ -149,18 +136,6 @@ Classifiers: Module: rail.estimation.algos.uniform_binning -# These describe all the algorithms that summarize PZ information into NZ distributions -Summarizers: - - Summarizer: - name: naive_stack - Summarize: NaiveStackMaskedSummarizer - Module: rail.estimation.algos.naive_stack - - Summarizer: - name: point_est_hist - Summarize: PointEstHistMaskedSummarizer - Module: rail.estimation.algos.point_est_hist - - # These describe the error models we use in the truth_to_observed pipeline ErrorModels: - ErrorModel: @@ -187,16 +162,6 @@ Subsamplers: # These describe the ways we can reduce the data Reducers: - - Reducer: - name: roman_rubin - Reduce: RomanRubinReducer - Module: rail.projects.reducer - - - Reducer: - name: flagship - Reduce: FlagshipReducer - Module: rail.projects.reducer - - Reducer: name: cardinal Reduce: CardinalReducer @@ -226,12 +191,6 @@ Pipelines: output_catalog_template: degraded kwargs: error_models: ['all'] - - PipelineTemplate: - name: blending - input_catalog_template: degraded - output_catalog_template: degraded - pipeline_class: rail.pipelines.degradation.blending.BlendingPipeline - kwargs: {} - PipelineTemplate: name: spec_selection input_catalog_template: degraded @@ -287,104 +246,6 @@ Pipelines: tag: test kwargs: algorithms: ['all'] - - PipelineTemplate: - name: inform_sompz - pipeline_class: rail.pipelines.estimation.inform_sompz.InformSomPZPipeline - input_file_templates: - input_deep_data: - flavor: baseline - tag: deep - input_wide_data: - flavor: baseline - tag: wide - kwargs: - wide_catalog_tag: SompzWideTestCatalogConfig - deep_catalog_tag: SompzDeepTestCatalogConfig - catalog_module: rail.sompz.utils - - PipelineTemplate: - name: estimate_sompz - pipeline_class: rail.pipelines.estimation.estimate_sompz.EstimateSomPZPipeline - input_file_templates: - input_deep: - flavor: baseline - tag: deep - input_wide: - flavor: baseline - tag: wide - input_spec: - flavor: baseline - tag: spec - kwargs: - wide_catalog_tag: SompzWideTestCatalogConfig - catalog_module: rail.sompz.utils - deep_catalog_tag: SompzDeepTestCatalogConfig - - PipelineTemplate: - name: inform_somlike - pipeline_class: rail.pipelines.calib.inform_somlike.InformSomlikePipeline - input_file_templates: - input_spec_data: - flavor: baseline - tag: spec - kwargs: - algorithms: ['all'] - wide_catalog_tag: SompzWideTestCatalogConfig - deep_catalog_tag: SompzDeepTestCatalogConfig - catalog_module: rail.sompz.utils - - PipelineTemplate: - name: somlike_recalib - pipeline_class: rail.pipelines.calib.somlike_recalib.SomlikeRecalibPipeline - input_file_templates: - input_deep: - flavor: baseline - tag: deep - input_wide: - flavor: baseline - tag: wide - input_spec: - flavor: baseline - tag: spec - kwargs: - algorithms: ['all'] - assign_algos: null - wide_catalog_tag: SompzWideTestCatalogConfig - catalog_module: rail.sompz.utils - deep_catalog_tag: SompzDeepTestCatalogConfig - - PipelineTemplate: - name: inform_recalib - pipeline_class: rail.pipelines.calib.inform_recalib.InformRecalibPipeline - input_file_templates: - truth: - flavor: baseline - tag: test - kwargs: - algorithms: ['all'] - recalib_algos: null - - PipelineTemplate: - name: estimate_recalib - pipeline_class: rail.pipelines.calib.estimate_recalib.EstimateRecalibPipeline - input_file_templates: - input: - flavor: baseline - tag: test - kwargs: - algorithms: ['all'] - recalib_algos: null - - PipelineTemplate: - name: tomography - pipeline_class: rail.pipelines.estimation.tomography.TomographyPipeline - input_catalog_template: degraded - output_catalog_template: degraded - input_file_templates: - truth: - flavor: baseline - tag: test - kwargs: - algorithms: ['all'] - classifiers: ['all'] - summarizers: ['all'] - n_tomo_bins: 5 - - # These describe the selections going from "truth" to "reduced" catalog # These just all use different limiting i-band magnitudes @@ -412,52 +273,21 @@ Selections: # These describe the subsampling used to make test and training datasets Subsamples: - # Testing subsample with 100k events + # Testing subsample with 100 events - Subsample: - name: test_100k + name: test_100 seed: 1234 - num_objects: 100000 + num_objects: 100 # Training subsample with 100k events, and a different seed to select the events - Subsample: - name: train_100k + name: train_100 seed: 4321 - num_objects: 100000 + num_objects: 100 # Training subsample with 100k events, and a different seed to select the events - Subsample: - name: train_10 - seed: 5555 - num_objects: 100000 - - Subsample: - name: multi_catalog + name: train_101 seed: 5555 - num_objects: 1000 - weight_map: "tests/dummy_weight_map.fits" - cuts: # data selection cuts - - ['ra', '>', 45] - - ['ra', '<', 47] - - ['dec', '>', 101] - - ['dec', '<', 102] - inputs: # All the inputs - rubin: # rubin input config - basename: output_lsst_wfd_1yr.pq # file to look for - bands: ['u', 'g', 'r', 'i', 'z', 'y'] # bands to consider - mag_band_name_template: "{band}_cModelMag" # template for columns - mag_err_band_name_template: "{band}_cModelMagErr" # template for columns - extra_cols: [] # extra columns to copy - cuts: - - ['i_cModelMag', '<', 25] - roman: - basename: output_roman_medium.pq - bands: ['Y106', 'J129', 'H158'] - mag_band_name_template: "ROMAN_obs_{band}" - mag_err_band_name_template: "ROMAN_obs_{band}_err" - extra_cols: [] - euclid: - basename: output_euclid_3band.pq - bands: ['Y', 'J', 'H'] - mag_band_name_template: "euclid_{band}_unifMag" - mag_err_band_name_template: "euclid_{band}_unifMagErr" - extra_cols: [] + num_objects: 101 # These describe the ways we can split the data Splitters: diff --git a/tests/projects/test_cardinal_project.py b/tests/projects/test_cardinal_project.py new file mode 100644 index 0000000..15e229a --- /dev/null +++ b/tests/projects/test_cardinal_project.py @@ -0,0 +1,190 @@ +import os +from typing import Any, Callable + +import pytest + +from rail.projects.project import RailProject + + +def check_get_func(func: Callable, check_dict: dict[str, Any]) -> None: + for key, val in check_dict.items(): + check_val = func(key) + if isinstance(check_val, dict): + for kk, vv in check_val.items(): + assert vv == val[kk] + with pytest.raises(KeyError): + func("does_not_exist") + + +def test_project_doc() -> None: + RailProject.functionality_help() + RailProject.configuration_help() + + +def test_project_class(setup_project_area: int) -> None: + assert setup_project_area == 0 + + project = RailProject.load_config("tests/ci_cardinal_project.yaml") + + print(project) + + templates = project.get_path_templates() + check_get_func(project.get_path, templates) + + common_paths = project.get_common_paths() + check_get_func(project.get_common_path, common_paths) + + files = project.get_files() + check_get_func(project.get_file, files) + + flavors = project.get_flavors() + check_get_func(project.get_flavor, flavors) + all_flavors = project.get_flavor_args(["all"]) + assert set(all_flavors) == set(flavors.keys()) + assert project.get_flavor_args(["dummy"])[0] == "dummy" + + project.get_file_for_flavor("baseline", "test") + with pytest.raises(KeyError): + project.get_file_for_flavor("baseline", "does not exist") + + project.get_file_metadata_for_flavor("baseline", "test") + with pytest.raises(KeyError): + project.get_file_metadata_for_flavor("baseline", "does not exist") + + selections = project.get_selections() + check_get_func(project.get_selection, selections) + project.clear_cache() + check_get_func(project.get_selection, selections) + all_selections = project.get_selection_args(["all"]) + assert set(all_selections) == set(selections.keys()) + assert project.get_selection_args(["dummy"])[0] == "dummy" + + subsamples = project.get_subsamples() + check_get_func(project.get_subsample, subsamples) + + itr = project.generate_kwargs_iterable( + selections=all_selections, + flavors=all_flavors, + ) + for x_ in itr: + assert isinstance(x_, dict) + + error_models = project.get_error_models() + check_get_func(project.get_error_model, error_models) + + pz_algos = project.get_pzalgorithms() + check_get_func(project.get_pzalgorithm, pz_algos) + + spec_selections = project.get_spec_selections() + check_get_func(project.get_spec_selection, spec_selections) + + classifiers = project.get_classifiers() + check_get_func(project.get_classifier, classifiers) + + summarizers = project.get_summarizers() + check_get_func(project.get_summarizer, summarizers) + + catalogs = project.get_catalogs() + check_get_func(project.get_catalog, catalogs) + + pipelines = project.get_pipelines() + check_get_func(project.get_pipeline, pipelines) + + _ceci_command = project.generate_ceci_command( + pipeline_path="dummy.yaml", + config=None, + inputs={"bob": "bob.pkl"}, + output_dir=".", + log_dir=".", + alice="bob", + ) + + project.build_pipelines(flavor="baseline") + + catalog_files_truth = project.get_catalog_files("truth") + check_path = "tests/temp_data/data/ci_test_v1.1.3/58/cardinal_test-0.parquet" + assert check_path in catalog_files_truth + + catalog_files_reduced = project.get_catalog_files("reduced", selection="gold") + check_path = "tests/temp_data/data/ci_test_v1.1.3/ci_test_gold/58/cardinal_test_file-0.pq" + assert check_path in catalog_files_reduced + + catalog_files_degraded = project.get_catalog_files( + "degraded", selection="gold", flavor="baseline", basename="output.hdf5" + ) + check_path = "tests/temp_data/data/ci_test_v1.1.3/ci_test_gold_baseline/58/output.hdf5" + assert check_path in catalog_files_degraded + + project.reduce_data( + catalog_template="truth", + output_catalog_template="reduced", + reducer_class_name="cardinal", + input_selection="", + selection="gold", + ) + + project.subsample_data( + catalog_template="reduced", + file_template="train_100", + subsampler_class_name="random_subsampler", + subsample_name="train_100", + flavor="baseline", + selection="gold", + ) + + project.split_data( + file_template="train_100", + test_file_template="test_split_file", + train_file_template="train_split_file", + splitter_class_name="random_splitter", + flavor="baseline", + selection="gold", + ) + + single_ceci_command = project.make_pipeline_single_input_command( + pipeline_name="pz", + flavor="baseline", + selection="gold", + ) + assert single_ceci_command + + ceci_catalog_commands = project.make_pipeline_catalog_commands( + pipeline_name="spec_selection", + flavor="baseline", + selection="gold", + spec_selections=list(project.get_spec_selections().keys()), + ) + assert ceci_catalog_commands + + project.write_yaml("tests/temp.yaml") + + RailProject.projects.clear() + + project = RailProject.load_config("tests/temp.yaml") + os.unlink("tests/temp.yaml") + project.get_file_for_flavor("baseline", "test") + + project.add_flavor( + name="test_flavor", + catalog_tag="cardinal", + pipelines=["pz"], + ) + with pytest.raises(KeyError): + project.add_flavor( + name="test_flavor", + catalog_tag="cardinal", + pipelines=["pz"], + ) + + flavor_info = project.get_flavor("test_flavor") + assert flavor_info + + model_path = ( + "tests/temp_data/projects/ci_test/data/blend_baseline/model_inform_knn.pkl" + ) + project.wrap_pz_model( + model_path, + "tests/temp_data", + selection="blend", + flavor="baseline", + ) From 4dacadb85673fe17cd2b50921892412efb97ee22 Mon Sep 17 00:00:00 2001 From: Sam Schmidt Date: Tue, 10 Feb 2026 16:49:03 -0800 Subject: [PATCH 08/11] add more healpix --- examples/cardinal_project.yaml | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/examples/cardinal_project.yaml b/examples/cardinal_project.yaml index 5277061..5b09534 100644 --- a/examples/cardinal_project.yaml +++ b/examples/cardinal_project.yaml @@ -49,7 +49,12 @@ Project: # These are variables that we iterate over when running over entire catalogs IterationVars: healpix: + - 427 + - 428 + - 429 - 430 + - 431 + - 432 - 73 - 122 - 99 From a0cadb67c28e348dd68c5bfccd8ca37776ebff25 Mon Sep 17 00:00:00 2001 From: Sam Schmidt Date: Tue, 10 Feb 2026 17:16:32 -0800 Subject: [PATCH 09/11] remove old yaml, replace notebook --- examples/ci_project-cardinal.yaml | 59 -- examples/rail_project_example.ipynb | 312 ----------- examples/rail_project_example_Cardinal.ipynb | 539 +++++++++++++++++++ 3 files changed, 539 insertions(+), 371 deletions(-) delete mode 100644 examples/ci_project-cardinal.yaml delete mode 100644 examples/rail_project_example.ipynb create mode 100644 examples/rail_project_example_Cardinal.ipynb diff --git a/examples/ci_project-cardinal.yaml b/examples/ci_project-cardinal.yaml deleted file mode 100644 index 6b4fed8..0000000 --- a/examples/ci_project-cardinal.yaml +++ /dev/null @@ -1,59 +0,0 @@ -Project: - - Name: ci_test_cardinal - - # Include other configuration files - Includes: - - examples/ci_cardinal_project_library.yaml - - PathTemplates: {} - - CommonPaths: - root: /global/cfs/cdirs/lsst/groups/PZ/Cardinal - scratch_root: "{root}" - catalogs_dir: "{root}/parquet_files" - project: ci_test_cardinal - sim_version: v1 - - # Baseline configuraiton, included in others by default - Baseline: - catalog_tag: cardinal - pipelines: ['all'] - file_aliases: # Set the training and test files - test: test_file_100k - train: train_file_100k - train_zCOSMOS: train_file_zCOSMOS_100k - wide: wide_file_full - deep: deep_file_full - spec: spec_file_full - - # These define the variant configurations for the various parts of the analysis - Flavors: - - Flavor: - name: train_cosmos - pipelines: ['pz', 'tomography'] - file_aliases: # Set the training and test files - test: test_file_100k - train: train_file_zCOSMOS_100k - - Flavor: - name: gpz_gl - pipelines: ['pz'] # only run the pz pipeline - pipeline_overrides: # Override specifics for particular pipelines - default: - kwargs: - algorithms: ['gpz'] # Only run gpz - inform: - inform_gpz: - gpz_method: GL - - # These are variables that we iterate over when running over entire catalogs - IterationVars: - healpix: - - 430 - - 73 - - 122 - - 99 - - 16 - - 58 - - 277 - - 346 diff --git a/examples/rail_project_example.ipynb b/examples/rail_project_example.ipynb deleted file mode 100644 index 8ddae36..0000000 --- a/examples/rail_project_example.ipynb +++ /dev/null @@ -1,312 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "3f31a160-8ce9-4fe6-8805-9df7a97b7adc", - "metadata": {}, - "source": [ - "## Using `RailProject` \n", - "\n", - "This notebook will show you the basics using the `RailProject` class to manage an analysis project" - ] - }, - { - "cell_type": "markdown", - "id": "d436cc4a-49c9-4f27-93cf-9a196d251a77", - "metadata": {}, - "source": [ - "### Setup and teardown scripts to setup a test area" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "96bee599-4711-4a07-b182-1cbe257ea4d8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "temp_data/\n", - "temp_data/data/\n", - "temp_data/data/ci_test_v1.1.3/\n", - "temp_data/data/ci_test_v1.1.3/9924/\n", - "temp_data/data/ci_test_v1.1.3/9924/part-0.parquet\n", - "temp_data/data/ci_test_v1.1.3/9925/\n", - "temp_data/data/ci_test_v1.1.3/9925/part-0.parquet\n", - "temp_data/projects/\n", - "temp_data/projects/ci_test/\n", - "temp_data/projects/ci_test/data/\n", - "temp_data/projects/ci_test/data/blend_baseline/\n", - "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_equal_count_bin2.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin3_point_est_hist.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_estimate_trainz.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin2_naive_stack.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin0_naive_stack.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin1_naive_stack.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin2_naive_stack.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_uniform_binning_bin3.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_evaluate_fzboost.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_uniform_binning_bin4.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_equal_count_bin1.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin4_point_est_hist.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/model_inform_simplenn.pkl\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin0_point_est_hist.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_equal_count_bin3.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin4_naive_stack.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin1_point_est_hist.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin3_naive_stack.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin1_point_est_hist.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin1_naive_stack.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_estimate_knn.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin4_point_est_hist.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin0_point_est_hist.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_evaluate_knn.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_evaluate_trainz.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/model_inform_gpz.pkl\n", - "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_uniform_binning_bin1.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_uniform_binning_bin2.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_estimate_gpz.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_estimate_fzboost.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_estimate_bpz.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_uniform_binning_bin0.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin4_naive_stack.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin2_point_est_hist.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/model_inform_sompz.pkl\n", - "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_equal_count_bin0.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/true_NZ_true_nz_knn_equal_count_bin4.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_estimate_simplenn.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin2_point_est_hist.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_equal_count_bin3_naive_stack.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_evaluate_simplenn.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin0_naive_stack.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/single_NZ_summarize_knn_uniform_binning_bin3_point_est_hist.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/output_evaluate_gpz.hdf5\n", - "temp_data/projects/ci_test/data/blend_baseline/model_inform_knn.pkl\n", - "temp_data/projects/ci_test/data/blend_baseline/model_inform_fzboost.pkl\n", - "temp_data/projects/ci_test/data/blend_baseline/model_inform_bpz.pkl\n", - "temp_data/projects/ci_test/data/blend_baseline/model_inform_train_z.pkl\n", - "temp_data/projects/ci_test/data/blend_baseline/model_inform_trainz.pkl\n" - ] - } - ], - "source": [ - "import os\n", - "from rail.projects import library\n", - "\n", - "check_dir = os.path.basename(os.path.abspath(os.curdir))\n", - "if check_dir == 'examples':\n", - " os.chdir('..')\n", - "\n", - "setup = library.setup_project_area()\n", - "assert setup == 0\n", - "\n", - "# use this to cleanup\n", - "# library.teardown_project_area()" - ] - }, - { - "cell_type": "markdown", - "id": "454c1464-aa61-4a0c-96b9-f48f5ddb94f6", - "metadata": {}, - "source": [ - "### Load the test project" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "7136e23a-43f1-4a36-ba77-03b9a649c449", - "metadata": {}, - "outputs": [], - "source": [ - "from rail.projects import RailProject\n", - "\n", - "project = RailProject.load_config(\"tests/ci_project.yaml\")" - ] - }, - { - "cell_type": "markdown", - "id": "57c75f4c-23f4-415b-8148-5b39754b5770", - "metadata": {}, - "source": [ - "### Inspect the test project" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "f47f06c0-2718-4cdd-aaa9-156341336907", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['tests/temp_data/data/ci_test_v1.1.3/9924/part-0.parquet', 'tests/temp_data/data/ci_test_v1.1.3/9925/part-0.parquet']\n" - ] - } - ], - "source": [ - "catalog_files_truth = project.get_catalog_files(\"truth\")\n", - "print(catalog_files_truth)" - ] - }, - { - "cell_type": "markdown", - "id": "d37d65cf-6fbe-4fcd-818f-6eaa6a0aa88d", - "metadata": {}, - "source": [ - "### Run a data reduction algorithm on the test project data\n", - "\n", - "This will use the \"roman_rubin\" reducer to apply the \"gold\" selection to the \"truth\" catalog to make a \"reduced\" catalog" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "1e4a8135-8131-473b-a132-b9be2109dbe0", - "metadata": {}, - "outputs": [], - "source": [ - "project.reduce_data(\n", - " catalog_template=\"truth\",\n", - " output_catalog_template=\"reduced\",\n", - " reducer_class_name=\"roman_rubin\",\n", - " input_selection=\"\",\n", - " selection=\"gold\",\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "id": "a70ff5d0-2e93-47e9-b5d4-7d791e883d9f", - "metadata": {}, - "source": [ - "### Subsample the test project\n", - "\n", - "This will use the \"random_subsampler\" to apply the \"train_10\" subsample to the \"reduced\" catalog of the baseline flavor with the gold selection" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "e6b79133-b695-433c-a47f-91bfa9fffc97", - "metadata": {}, - "outputs": [], - "source": [ - "project.subsample_data(\n", - " catalog_template=\"reduced\",\n", - " file_template=\"train_file_10\",\n", - " subsampler_class_name=\"random_subsampler\",\n", - " subsample_name=\"train_10\",\n", - " flavor=\"baseline\",\n", - " selection=\"gold\",\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "45aede11-ea93-4dab-b7e2-e2d108079ac3", - "metadata": {}, - "source": [ - "### Build all the pipelines for the \"baseline\" flavor" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "90ca72b7-bd09-4774-996b-8f4e6ca2bc6f", - "metadata": {}, - "outputs": [], - "source": [ - "project.build_pipelines(flavor=\"baseline\")" - ] - }, - { - "cell_type": "markdown", - "id": "37354004-48a7-48eb-af8f-b87154be1c8a", - "metadata": {}, - "source": [ - "### Generate the commands to run the \"pz\" pipeline in the \"baseline\" flavor for the \"gold\" selection" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2dd52439-1f2e-4ca6-91c6-ed2b9ffb859d", - "metadata": {}, - "outputs": [], - "source": [ - "single_ceci_command = project.make_pipeline_single_input_command(\n", - " pipeline_name=\"pz\",\n", - " flavor=\"basline\",\n", - " selection=\"gold\",\n", - ")\n", - "print(single_ceci_command)" - ] - }, - { - "cell_type": "markdown", - "id": "ff29b713-902e-41a5-94ce-f852eb5e461e", - "metadata": {}, - "source": [ - "### Generate the commands to run the \"spec_selection\" pipeline in the \"baseline\" flavor for the \"gold\" selection" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "c6461441-b51e-42f0-bb86-9a5d3b0513c3", - "metadata": {}, - "outputs": [], - "source": [ - "ceci_catalog_commands = project.make_pipeline_catalog_commands(\n", - " pipeline_name=\"spec_selection\",\n", - " flavor=\"basline\",\n", - " selection=\"gold\",\n", - " spec_selections = list(project.get_spec_selections().keys()),\n", - ")\n", - "print(ceci_catalog_commands)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "2e8f3aee-ae84-4a99-9835-797350b94cbf", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "13d8b9e3-7603-45d2-bc71-4b50c326c102", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "testenv", - "language": "python", - "name": "testenv" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.12" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/rail_project_example_Cardinal.ipynb b/examples/rail_project_example_Cardinal.ipynb new file mode 100644 index 0000000..1d30c7e --- /dev/null +++ b/examples/rail_project_example_Cardinal.ipynb @@ -0,0 +1,539 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3f31a160-8ce9-4fe6-8805-9df7a97b7adc", + "metadata": {}, + "source": [ + "## Using `RailProject` \n", + "\n", + "This notebook will show you the basics using the `RailProject` class to manage an analysis project" + ] + }, + { + "cell_type": "markdown", + "id": "d436cc4a-49c9-4f27-93cf-9a196d251a77", + "metadata": {}, + "source": [ + "### Setup and teardown scripts to setup a test area" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "96bee599-4711-4a07-b182-1cbe257ea4d8", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "#from rail.projects import library\n", + "#\n", + "check_dir = os.path.basename(os.path.abspath(os.curdir))\n", + "if check_dir == 'examples':\n", + " os.chdir('..')\n", + "\n", + "#setup = library.setup_project_area()\n", + "#assert setup == 0\n", + "\n", + "# use this to cleanup\n", + "# library.teardown_project_area()" + ] + }, + { + "cell_type": "markdown", + "id": "454c1464-aa61-4a0c-96b9-f48f5ddb94f6", + "metadata": {}, + "source": [ + "### Load the test project" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "7136e23a-43f1-4a36-ba77-03b9a649c449", + "metadata": {}, + "outputs": [], + "source": [ + "from rail.projects import RailProject\n", + "\n", + "project = RailProject.load_config(\"./examples/cardinal_project.yaml\")" + ] + }, + { + "cell_type": "markdown", + "id": "57c75f4c-23f4-415b-8148-5b39754b5770", + "metadata": {}, + "source": [ + "### Inspect the test project" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f47f06c0-2718-4cdd-aaa9-156341336907", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.427.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.428.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.429.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.430.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.431.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.432.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.73.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.122.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.99.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.16.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.58.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.277.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.346.parquet']\n" + ] + } + ], + "source": [ + "catalog_files_truth = project.get_catalog_files(\"truth\")\n", + "print(catalog_files_truth)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9629079a-b8f1-418b-b7ba-46f3d0c8830a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.427.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.428.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.429.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.430.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.431.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.432.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.73.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.122.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.99.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.16.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.58.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.277.parquet',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.346.parquet']" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "list(catalog_files_truth)" + ] + }, + { + "cell_type": "markdown", + "id": "d37d65cf-6fbe-4fcd-818f-6eaa6a0aa88d", + "metadata": {}, + "source": [ + "### Run a data reduction algorithm on the test project data\n", + "\n", + "This will use the \"roman_rubin\" reducer to apply the \"gold\" selection to the \"truth\" catalog to make a \"reduced\" catalog" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "1e4a8135-8131-473b-a132-b9be2109dbe0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/427/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/428/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/429/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/430/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/431/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/432/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/73/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/122/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/99/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/16/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/58/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/277/Chinchilla-3-triofile.pq\n", + "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/346/Chinchilla-3-triofile.pq\n" + ] + }, + { + "data": { + "text/plain": [ + "['/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/427/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/428/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/429/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/430/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/431/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/432/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/73/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/122/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/99/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/16/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/58/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/277/Chinchilla-3-triofile.pq',\n", + " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/346/Chinchilla-3-triofile.pq']" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.reduce_data(\n", + " catalog_template=\"truth\",\n", + " output_catalog_template=\"reduced\",\n", + " reducer_class_name=\"cardinal\",\n", + " input_selection=\"\",\n", + " selection=\"gold\",\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "a70ff5d0-2e93-47e9-b5d4-7d791e883d9f", + "metadata": {}, + "source": [ + "### Subsample the test project\n", + "\n", + "This will use the \"random_subsampler\" to apply the \"train_10\" subsample to the \"reduced\" catalog of the baseline flavor with the gold selection" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e6b79133-b695-433c-a47f-91bfa9fffc97", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "num rows 114320742\n", + "sampling 200000\n", + "writing /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test/test_cardinal_gold_baseline_200k.parquet\n", + "done\n" + ] + }, + { + "data": { + "text/plain": [ + "'/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test/test_cardinal_gold_baseline_200k.parquet'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "project.subsample_data(\n", + " catalog_template=\"reduced\",\n", + " file_template=\"train_file_200k\",\n", + " subsampler_class_name=\"random_subsampler\",\n", + " subsample_name=\"train_200k\",\n", + " flavor=\"baseline\",\n", + " selection=\"gold\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a07e4fbd-a75b-48f7-8c45-d249e39d2bf5", + "metadata": {}, + "outputs": [], + "source": [ + "import tables_io" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "95396640-4d02-41e0-a396-b118fc84035f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "column_list None\n" + ] + } + ], + "source": [ + "goldfile = \"/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test/test_cardinal_gold_baseline_200k.parquet\"\n", + "goldtab = tables_io.read(goldfile)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b83bdc4e-3652-4adc-a110-094b21aa9ef3", + "metadata": {}, + "outputs": [], + "source": [ + "golddf = tables_io.convert(goldtab, tables_io.types.PD_DATAFRAME)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "8680e7c9-e739-4793-9e32-a9c7b522f3c0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 200000 entries, 0 to 199999\n", + "Data columns (total 29 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 galaxy_id 200000 non-null float64\n", + " 1 ra 200000 non-null float64\n", + " 2 dec 200000 non-null float64\n", + " 3 sedid 200000 non-null int64 \n", + " 4 size 200000 non-null float64\n", + " 5 Ellipticity_1 200000 non-null float64\n", + " 6 Ellipticity_2 200000 non-null float64\n", + " 7 mag_u_lsst 200000 non-null float64\n", + " 8 mag_g_lsst 200000 non-null float64\n", + " 9 mag_r_lsst 200000 non-null float64\n", + " 10 mag_i_lsst 200000 non-null float64\n", + " 11 mag_z_lsst 200000 non-null float64\n", + " 12 mag_y_lsst 200000 non-null float64\n", + " 13 Roman_Y106 200000 non-null float64\n", + " 14 Roman_J129 200000 non-null float64\n", + " 15 Roman_H158 200000 non-null float64\n", + " 16 Roman_F184 200000 non-null float64\n", + " 17 Roman_K213 200000 non-null float64\n", + " 18 WISE_W1 200000 non-null float64\n", + " 19 WISE_W2 200000 non-null float64\n", + " 20 redshift 200000 non-null float64\n", + " 21 true_redshift 200000 non-null float64\n", + " 22 t_true_redshift 200000 non-null float64\n", + " 23 Euclid_Y 200000 non-null float64\n", + " 24 Euclid_J 200000 non-null float64\n", + " 25 Euclid_H 200000 non-null float64\n", + " 26 Euclid_redshift 200000 non-null float64\n", + " 27 Ellipticity1 200000 non-null float64\n", + " 28 Ellipticity2 200000 non-null float64\n", + "dtypes: float64(28), int64(1)\n", + "memory usage: 44.3 MB\n" + ] + } + ], + "source": [ + "golddf.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "61cb57b0-592a-41a2-9e0a-1bf95e6ae08f", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "55acb027-356c-4542-9242-f2bd6d689102", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,8))\n", + "plt.scatter(golddf['ra'], golddf['dec'], s=1, c='k')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "261d2f64-586a-42ee-a6fb-74870c91b4d3", + "metadata": {}, + "outputs": [], + "source": [ + "gr = golddf['mag_g_lsst'] - golddf['mag_r_lsst']" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "5e505542-9168-4e12-bbf2-ff304e11528a", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'g-r')" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,5))\n", + "plt.scatter(golddf['redshift'], gr, s=1,c='k')\n", + "plt.xlabel(\"redshift\")\n", + "plt.ylabel(\"g-r\")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0dc73824-0698-47c5-8928-c282ba474f7c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'z cosmological - z true')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# difference of cosmological redshift (w proper motion) - true z vs true redshift\n", + "delz = golddf['redshift'] - golddf['true_redshift']\n", + "plt.figure(figsize=(14,8))\n", + "plt.scatter(golddf['redshift'], delz, s=.1, c='k')\n", + "plt.xlabel(\"true redshift\")\n", + "plt.ylabel(\"z cosmological - z true\")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "25199fe0-e845-4f48-8ff5-ae28af2ca67a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# plot the redshift distribution of the \"gold\" i<25.5 sample:\n", + "import numpy as np\n", + "plt.figure(figsize=(10,6))\n", + "plt.hist(golddf['redshift'], bins=np.linspace(0,2.5,101));\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "b363711a-99ad-4e04-85f5-122f641e9504", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(8,6))\n", + "plt.scatter(golddf['redshift'], golddf['mag_i_lsst'], s=1, c='k', alpha=0.2)\n", + "plt.axhline(25.,c='r')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e26824a9-0dae-4192-a790-449e5c0eb3f7", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "testenv", + "language": "python", + "name": "testenv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From df393f6f2f9350533e11eedd3a315a988bac263a Mon Sep 17 00:00:00 2001 From: Sam Schmidt Date: Tue, 10 Feb 2026 17:24:02 -0800 Subject: [PATCH 10/11] nersc giving weird error didn't clear nb, try again --- examples/rail_project_example_Cardinal.ipynb | 308 ++----------------- 1 file changed, 29 insertions(+), 279 deletions(-) diff --git a/examples/rail_project_example_Cardinal.ipynb b/examples/rail_project_example_Cardinal.ipynb index 1d30c7e..74ad574 100644 --- a/examples/rail_project_example_Cardinal.ipynb +++ b/examples/rail_project_example_Cardinal.ipynb @@ -20,7 +20,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "96bee599-4711-4a07-b182-1cbe257ea4d8", "metadata": {}, "outputs": [], @@ -49,7 +49,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "7136e23a-43f1-4a36-ba77-03b9a649c449", "metadata": {}, "outputs": [], @@ -69,18 +69,10 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "f47f06c0-2718-4cdd-aaa9-156341336907", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "['/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.427.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.428.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.429.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.430.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.431.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.432.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.73.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.122.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.99.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.16.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.58.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.277.parquet', '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.346.parquet']\n" - ] - } - ], + "outputs": [], "source": [ "catalog_files_truth = project.get_catalog_files(\"truth\")\n", "print(catalog_files_truth)" @@ -88,33 +80,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "9629079a-b8f1-418b-b7ba-46f3d0c8830a", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.427.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.428.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.429.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.430.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.431.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.432.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.73.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.122.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.99.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.16.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.58.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.277.parquet',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/Chinchilla-3-triofile.346.parquet']" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "list(catalog_files_truth)" ] @@ -131,52 +100,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "1e4a8135-8131-473b-a132-b9be2109dbe0", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/427/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/428/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/429/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/430/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/431/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/432/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/73/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/122/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/99/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/16/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/58/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/277/Chinchilla-3-triofile.pq\n", - "writing dataset to /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/346/Chinchilla-3-triofile.pq\n" - ] - }, - { - "data": { - "text/plain": [ - "['/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/427/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/428/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/429/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/430/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/431/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/432/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/73/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/122/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/99/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/16/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/58/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/277/Chinchilla-3-triofile.pq',\n", - " '/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test_cardinal_gold/346/Chinchilla-3-triofile.pq']" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "project.reduce_data(\n", " catalog_template=\"truth\",\n", @@ -199,31 +126,10 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "e6b79133-b695-433c-a47f-91bfa9fffc97", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "num rows 114320742\n", - "sampling 200000\n", - "writing /global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test/test_cardinal_gold_baseline_200k.parquet\n", - "done\n" - ] - }, - { - "data": { - "text/plain": [ - "'/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test/test_cardinal_gold_baseline_200k.parquet'" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "project.subsample_data(\n", " catalog_template=\"reduced\",\n", @@ -237,7 +143,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "a07e4fbd-a75b-48f7-8c45-d249e39d2bf5", "metadata": {}, "outputs": [], @@ -247,18 +153,10 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "95396640-4d02-41e0-a396-b118fc84035f", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "column_list None\n" - ] - } - ], + "outputs": [], "source": [ "goldfile = \"/global/cfs/cdirs/lsst/groups/PZ/Cardinal/parquet_files/test/test_cardinal_gold_baseline_200k.parquet\"\n", "goldtab = tables_io.read(goldfile)" @@ -266,7 +164,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "b83bdc4e-3652-4adc-a110-094b21aa9ef3", "metadata": {}, "outputs": [], @@ -276,60 +174,17 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "8680e7c9-e739-4793-9e32-a9c7b522f3c0", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "RangeIndex: 200000 entries, 0 to 199999\n", - "Data columns (total 29 columns):\n", - " # Column Non-Null Count Dtype \n", - "--- ------ -------------- ----- \n", - " 0 galaxy_id 200000 non-null float64\n", - " 1 ra 200000 non-null float64\n", - " 2 dec 200000 non-null float64\n", - " 3 sedid 200000 non-null int64 \n", - " 4 size 200000 non-null float64\n", - " 5 Ellipticity_1 200000 non-null float64\n", - " 6 Ellipticity_2 200000 non-null float64\n", - " 7 mag_u_lsst 200000 non-null float64\n", - " 8 mag_g_lsst 200000 non-null float64\n", - " 9 mag_r_lsst 200000 non-null float64\n", - " 10 mag_i_lsst 200000 non-null float64\n", - " 11 mag_z_lsst 200000 non-null float64\n", - " 12 mag_y_lsst 200000 non-null float64\n", - " 13 Roman_Y106 200000 non-null float64\n", - " 14 Roman_J129 200000 non-null float64\n", - " 15 Roman_H158 200000 non-null float64\n", - " 16 Roman_F184 200000 non-null float64\n", - " 17 Roman_K213 200000 non-null float64\n", - " 18 WISE_W1 200000 non-null float64\n", - " 19 WISE_W2 200000 non-null float64\n", - " 20 redshift 200000 non-null float64\n", - " 21 true_redshift 200000 non-null float64\n", - " 22 t_true_redshift 200000 non-null float64\n", - " 23 Euclid_Y 200000 non-null float64\n", - " 24 Euclid_J 200000 non-null float64\n", - " 25 Euclid_H 200000 non-null float64\n", - " 26 Euclid_redshift 200000 non-null float64\n", - " 27 Ellipticity1 200000 non-null float64\n", - " 28 Ellipticity2 200000 non-null float64\n", - "dtypes: float64(28), int64(1)\n", - "memory usage: 44.3 MB\n" - ] - } - ], + "outputs": [], "source": [ "golddf.info()" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "61cb57b0-592a-41a2-9e0a-1bf95e6ae08f", "metadata": {}, "outputs": [], @@ -339,31 +194,10 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "55acb027-356c-4542-9242-f2bd6d689102", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(8,8))\n", "plt.scatter(golddf['ra'], golddf['dec'], s=1, c='k')" @@ -371,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "id": "261d2f64-586a-42ee-a6fb-74870c91b4d3", "metadata": {}, "outputs": [], @@ -381,31 +215,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "5e505542-9168-4e12-bbf2-ff304e11528a", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'g-r')" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plt.figure(figsize=(8,5))\n", "plt.scatter(golddf['redshift'], gr, s=1,c='k')\n", @@ -415,31 +228,10 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "0dc73824-0698-47c5-8928-c282ba474f7c", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'z cosmological - z true')" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# difference of cosmological redshift (w proper motion) - true z vs true redshift\n", "delz = golddf['redshift'] - golddf['true_redshift']\n", @@ -451,59 +243,17 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "25199fe0-e845-4f48-8ff5-ae28af2ca67a", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# plot the redshift distribution of the \"gold\" i<25.5 sample:\n", "import numpy as np\n", "plt.figure(figsize=(10,6))\n", - "plt.hist(golddf['redshift'], bins=np.linspace(0,2.5,101));\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "b363711a-99ad-4e04-85f5-122f641e9504", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plt.figure(figsize=(8,6))\n", - "plt.scatter(golddf['redshift'], golddf['mag_i_lsst'], s=1, c='k', alpha=0.2)\n", - "plt.axhline(25.,c='r')" + "plt.hist(golddf['redshift'], bins=np.linspace(0,2.5,101), color='k');\n", + "plt.xlabel(\"redshift\")\n", + "plt.ylabel(\"Number\")" ] }, { From 9dcf3332504c61ab02df76e209cec973c8ab1aa5 Mon Sep 17 00:00:00 2001 From: Sam Schmidt Date: Tue, 10 Feb 2026 18:00:22 -0800 Subject: [PATCH 11/11] switch back to s3df to grab data file --- examples/rail_project_example.ipynb | 237 ++++++++++++++++++++++++++++ src/rail/projects/library.py | 4 +- 2 files changed, 239 insertions(+), 2 deletions(-) create mode 100644 examples/rail_project_example.ipynb diff --git a/examples/rail_project_example.ipynb b/examples/rail_project_example.ipynb new file mode 100644 index 0000000..c5ae8cb --- /dev/null +++ b/examples/rail_project_example.ipynb @@ -0,0 +1,237 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3f31a160-8ce9-4fe6-8805-9df7a97b7adc", + "metadata": {}, + "source": [ + "## Using `RailProject` \n", + "\n", + "This notebook will show you the basics using the `RailProject` class to manage an analysis project" + ] + }, + { + "cell_type": "markdown", + "id": "d436cc4a-49c9-4f27-93cf-9a196d251a77", + "metadata": {}, + "source": [ + "### Setup and teardown scripts to setup a test area" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "96bee599-4711-4a07-b182-1cbe257ea4d8", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from rail.projects import library\n", + "\n", + "check_dir = os.path.basename(os.path.abspath(os.curdir))\n", + "if check_dir == 'examples':\n", + " os.chdir('..')\n", + "\n", + "setup = library.setup_project_area()\n", + "assert setup == 0\n", + "\n", + "# use this to cleanup\n", + "# library.teardown_project_area()" + ] + }, + { + "cell_type": "markdown", + "id": "454c1464-aa61-4a0c-96b9-f48f5ddb94f6", + "metadata": {}, + "source": [ + "### Load the test project" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7136e23a-43f1-4a36-ba77-03b9a649c449", + "metadata": {}, + "outputs": [], + "source": [ + "from rail.projects import RailProject\n", + "\n", + "project = RailProject.load_config(\"tests/ci_project.yaml\")" + ] + }, + { + "cell_type": "markdown", + "id": "57c75f4c-23f4-415b-8148-5b39754b5770", + "metadata": {}, + "source": [ + "### Inspect the test project" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f47f06c0-2718-4cdd-aaa9-156341336907", + "metadata": {}, + "outputs": [], + "source": [ + "catalog_files_truth = project.get_catalog_files(\"truth\")\n", + "print(catalog_files_truth)" + ] + }, + { + "cell_type": "markdown", + "id": "d37d65cf-6fbe-4fcd-818f-6eaa6a0aa88d", + "metadata": {}, + "source": [ + "### Run a data reduction algorithm on the test project data\n", + "\n", + "This will use the \"roman_rubin\" reducer to apply the \"gold\" selection to the \"truth\" catalog to make a \"reduced\" catalog" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1e4a8135-8131-473b-a132-b9be2109dbe0", + "metadata": {}, + "outputs": [], + "source": [ + "project.reduce_data(\n", + " catalog_template=\"truth\",\n", + " output_catalog_template=\"reduced\",\n", + " reducer_class_name=\"roman_rubin\",\n", + " input_selection=\"\",\n", + " selection=\"gold\",\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "id": "a70ff5d0-2e93-47e9-b5d4-7d791e883d9f", + "metadata": {}, + "source": [ + "### Subsample the test project\n", + "\n", + "This will use the \"random_subsampler\" to apply the \"train_10\" subsample to the \"reduced\" catalog of the baseline flavor with the gold selection" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6b79133-b695-433c-a47f-91bfa9fffc97", + "metadata": {}, + "outputs": [], + "source": [ + "project.subsample_data(\n", + " catalog_template=\"reduced\",\n", + " file_template=\"train_file_10\",\n", + " subsampler_class_name=\"random_subsampler\",\n", + " subsample_name=\"train_10\",\n", + " flavor=\"baseline\",\n", + " selection=\"gold\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "45aede11-ea93-4dab-b7e2-e2d108079ac3", + "metadata": {}, + "source": [ + "### Build all the pipelines for the \"baseline\" flavor" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "90ca72b7-bd09-4774-996b-8f4e6ca2bc6f", + "metadata": {}, + "outputs": [], + "source": [ + "project.build_pipelines(flavor=\"baseline\")" + ] + }, + { + "cell_type": "markdown", + "id": "37354004-48a7-48eb-af8f-b87154be1c8a", + "metadata": {}, + "source": [ + "### Generate the commands to run the \"pz\" pipeline in the \"baseline\" flavor for the \"gold\" selection" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2dd52439-1f2e-4ca6-91c6-ed2b9ffb859d", + "metadata": {}, + "outputs": [], + "source": [ + "single_ceci_command = project.make_pipeline_single_input_command(\n", + " pipeline_name=\"pz\",\n", + " flavor=\"basline\",\n", + " selection=\"gold\",\n", + ")\n", + "print(single_ceci_command)" + ] + }, + { + "cell_type": "markdown", + "id": "ff29b713-902e-41a5-94ce-f852eb5e461e", + "metadata": {}, + "source": [ + "### Generate the commands to run the \"spec_selection\" pipeline in the \"baseline\" flavor for the \"gold\" selection" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c6461441-b51e-42f0-bb86-9a5d3b0513c3", + "metadata": {}, + "outputs": [], + "source": [ + "ceci_catalog_commands = project.make_pipeline_catalog_commands(\n", + " pipeline_name=\"spec_selection\",\n", + " flavor=\"basline\",\n", + " selection=\"gold\",\n", + " spec_selections = list(project.get_spec_selections().keys()),\n", + ")\n", + "print(ceci_catalog_commands)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "2e8f3aee-ae84-4a99-9835-797350b94cbf", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "13d8b9e3-7603-45d2-bc71-4b50c326c102", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "testenv", + "language": "python", + "name": "testenv" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/rail/projects/library.py b/src/rail/projects/library.py index f2dcb90..140f7e3 100644 --- a/src/rail/projects/library.py +++ b/src/rail/projects/library.py @@ -236,8 +236,8 @@ def setup_project_area() -> int: # pragma: no cover if not os.path.exists("tests/ci_test.tgz"): urllib.request.urlretrieve( - "https://portal.nersc.gov/cfs/lsst/PZ/test_data/ci_test.tgz", - # "http://s3df.slac.stanford.edu/people/echarles/xfer/ci_test.tgz", + # "https://portal.nersc.gov/cfs/lsst/PZ/test_data/ci_test.tgz", + "http://s3df.slac.stanford.edu/people/echarles/xfer/ci_test.tgz", "tests/ci_test.tgz", ) if not os.path.exists("tests/ci_test.tgz"):