cehrgpt 0.0.1__py3-none-any.whl

cehrgpt/tools/merge_synthetic_real_dataasets.py

@@ -0,0 +1,218 @@
+import argparse
+import logging
+import os
+import shutil
+from enum import Enum
+from typing import List
+
+from cehrbert_data.utils.logging_utils import add_console_logging
+from cehrbert_data.utils.spark_utils import validate_table_names
+from pyspark.sql import SparkSession
+from pyspark.sql import functions as F
+
+add_console_logging()
+logger = logging.getLogger(__name__)
+
+COHORT_FOLDER_NAME = "cohorts"
+
+
+class MergeType(Enum):
+    TRAIN_AND_TEST = "train_and_test"
+    TEST_ONLY = "test_only"
+
+
+def main(
+    real_omop_folder: str,
+    synthetic_omop_folder: str,
+    domain_table_list: List[str],
+    output_folder: str,
+    merge_type: str,
+):
+    spark = SparkSession.builder.appName(
+        "Merge Synthetic OMOP and Real OMOP datasets"
+    ).getOrCreate()
+
+    logger.info(
+        f"real_omop_folder: {real_omop_folder}\n"
+        f"synthetic_omop_folder: {synthetic_omop_folder}\n"
+        f"output_folder: {output_folder}\n"
+        f"domain_table_list: {domain_table_list}\n"
+        f"merge_type: {merge_type}\n"
+    )
+
+    patient_splits_folder = os.path.join(real_omop_folder, "patient_splits")
+    if not os.path.exists(patient_splits_folder):
+        raise RuntimeError(f"patient_splits must exist in {real_omop_folder}")
+
+    patient_splits = spark.read.parquet(patient_splits_folder)
+    patient_splits = patient_splits.select("person_id", "split")
+
+    # Generate the real patient splits
+    real_person = spark.read.parquet(os.path.join(real_omop_folder, "person"))
+    real_person = (
+        real_person.select("person_id")
+        .join(patient_splits, "person_id")
+        .withColumn("is_real", F.lit(1))
+    )
+    max_real_person_id = real_person.select(F.max("person_id")).collect()[0][0]
+    if merge_type == MergeType.TEST_ONLY.value:
+        real_person = real_person.where("split='test'")
+    synthetic_person = spark.read.parquet(os.path.join(synthetic_omop_folder, "person"))
+    synthetic_person = (
+        synthetic_person.select("person_id")
+        .withColumn("split", F.lit("train"))
+        .withColumn("is_real", F.lit(0))
+    )
+    merge_patient_splits = real_person.unionByName(synthetic_person)
+    merge_patient_splits = merge_patient_splits.withColumn(
+        "new_person_id",
+        F.when(F.col("is_real") == 1, F.col("person_id")).otherwise(
+            F.col("person_id") + F.lit(max_real_person_id)
+        ),
+    )
+    merge_patient_splits.cache()
+
+    # re-assign visit_occurrence_id
+    real_visit_occurrence = spark.read.parquet(
+        os.path.join(real_omop_folder, "visit_occurrence")
+    )
+    max_real_visit_occurrence_id = real_visit_occurrence.select(
+        F.max("visit_occurrence_id")
+    ).collect()[0][0]
+
+    synthetic_visit_occurrence_mapping = (
+        spark.read.parquet(os.path.join(synthetic_omop_folder, "visit_occurrence"))
+        .select("visit_occurrence_id")
+        .withColumn(
+            "new_visit_occurrence_id",
+            F.col("visit_occurrence_id") + F.lit(max_real_visit_occurrence_id),
+        )
+    )
+
+    for domain_table in domain_table_list:
+        real_domain_table = spark.read.parquet(
+            os.path.join(real_omop_folder, domain_table)
+        )
+        synthetic_domain_table = spark.read.parquet(
+            os.path.join(synthetic_omop_folder, domain_table)
+        )
+        # The synthetic and real datasets should have the same schema, this is the pre-caution to make sure the columns
+        # exist in both datasets
+        real_columns = real_domain_table.schema.fieldNames()
+        synthetic_columns = synthetic_domain_table.schema.fieldNames()
+        common_columns = [f for f in synthetic_columns if f in real_columns]
+
+        real_domain_table = real_domain_table.join(
+            merge_patient_splits,
+            (real_domain_table["person_id"] == merge_patient_splits["person_id"])
+            & (merge_patient_splits["is_real"] == 1),
+        ).select(
+            [real_domain_table[f] for f in common_columns]
+            + [
+                merge_patient_splits["is_real"],
+                merge_patient_splits["split"],
+                merge_patient_splits["new_person_id"],
+            ]
+        )
+
+        synthetic_domain_table = synthetic_domain_table.join(
+            merge_patient_splits,
+            (synthetic_domain_table["person_id"] == merge_patient_splits["person_id"])
+            & (merge_patient_splits["is_real"] == 0),
+        ).select(
+            [synthetic_domain_table[f] for f in common_columns]
+            + [
+                merge_patient_splits["is_real"],
+                merge_patient_splits["split"],
+                merge_patient_splits["new_person_id"],
+            ]
+        )
+        # Re-map visit_occurrence_id
+        if "visit_occurrence_id" in [
+            _.lower() for _ in synthetic_domain_table.schema.fieldNames()
+        ]:
+            synthetic_domain_table = (
+                synthetic_domain_table.join(
+                    synthetic_visit_occurrence_mapping, "visit_occurrence_id"
+                )
+                .drop("visit_occurrence_id")
+                .withColumnRenamed("new_visit_occurrence_id", "visit_occurrence_id")
+            )
+
+        merge_domain_table = real_domain_table.unionByName(synthetic_domain_table)
+        merge_domain_table = (
+            merge_domain_table.withColumnRenamed("person_id", "original_person_id")
+            .withColumnRenamed("new_person_id", "person_id")
+            .drop("new_person_id")
+        )
+        merge_domain_table.write.mode("overwrite").parquet(
+            os.path.join(output_folder, domain_table)
+        )
+
+    # Rename the columns for the patient splits dataframe
+    merge_patient_splits.withColumnRenamed(
+        "person_id", "original_person_id"
+    ).withColumnRenamed("new_person_id", "person_id").write.mode("overwrite").parquet(
+        os.path.join(output_folder, "patient_splits")
+    )
+
+    # Copy concept tables
+    for concept_table in ["concept", "concept_relationship", "concept_ancestor"]:
+        shutil.copytree(
+            os.path.join(real_omop_folder, concept_table),
+            os.path.join(output_folder, concept_table),
+        )
+
+
+def create_app_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Arguments for generate training data for Bert"
+    )
+    parser.add_argument(
+        "--real_omop_folder",
+        dest="real_omop_folder",
+        action="store",
+        help="The path for your input_folder where the Real OMOP folder is",
+        required=True,
+    )
+    parser.add_argument(
+        "--synthetic_omop_folder",
+        dest="synthetic_omop_folder",
+        action="store",
+        help="The path for your input_folder where the Synthetic OMOP folder is",
+        required=True,
+    )
+    parser.add_argument(
+        "--domain_table_list",
+        dest="domain_table_list",
+        nargs="+",
+        action="store",
+        help="The list of domain tables you want to download",
+        type=validate_table_names,
+        required=True,
+    )
+    parser.add_argument(
+        "--output_folder",
+        dest="output_folder",
+        action="store",
+        help="The path for your output_folder",
+        required=True,
+    )
+    parser.add_argument(
+        "--merge_type",
+        dest="merge_type",
+        action="store",
+        choices=[e.value for e in MergeType],
+    )
+    return parser
+
+
+if __name__ == "__main__":
+    ARGS = create_app_arg_parser().parse_args()
+    main(
+        ARGS.real_omop_folder,
+        ARGS.synthetic_omop_folder,
+        ARGS.domain_table_list,
+        ARGS.output_folder,
+        ARGS.merge_type,
+    )

cehrgpt/tools/upload_omop_tables.py

@@ -0,0 +1,108 @@
+import argparse
+import configparser
+from pathlib import Path
+
+import pyspark.sql.functions as f
+from pyspark.sql import SparkSession
+
+# Define timestamp column for filtering based on the folder name
+omop_timestamp_dict = {
+    "person": "birth_datetime",
+    "condition_occurrence": "condition_start_date",
+    "measurement": "measurement_date",
+    "drug_exposure": "drug_exposure_start_date",
+    "procedure_occurrence": "procedure_date",
+    "observation": "observation_date",
+    "visit_occurrence": "visit_start_date",
+}
+
+
+# Function to initialize and return the SparkSession
+def get_spark_session():
+    spark = (
+        SparkSession.builder.appName("OMOP Upload")
+        .config("spark.sql.legacy.parquet.int96RebaseModeInRead", "CORRECTED")
+        .config("spark.sql.legacy.parquet.int96RebaseModeInWrite", "CORRECTED")
+        .config("spark.sql.legacy.parquet.datetimeRebaseModeInRead", "CORRECTED")
+        .config("spark.sql.legacy.parquet.datetimeRebaseModeInWrite", "CORRECTED")
+        .getOrCreate()
+    )
+    return spark
+
+
+# Function to upload OMOP tables to a database
+def upload_omop_tables(spark, domain_table_folder, db_properties):
+    # Load parquet file from the specified folder
+    df = spark.read.format("parquet").load(str(domain_table_folder) + "/")
+
+    # Filter dates outside of the acceptable range
+    if domain_table_folder.name in omop_timestamp_dict:
+        timestamp_column = omop_timestamp_dict[domain_table_folder.name]
+        df = df.filter(f.col(timestamp_column) > f.lit("1900-01-01").cast("date"))
+        df = df.filter(f.col(timestamp_column) < f.lit("9999-01-01").cast("date"))
+
+    # Cast appropriate columns to integer and date types
+    for column in df.columns:
+        if "concept_id" in column:
+            df = df.withColumn(column, f.col(column).cast("integer"))
+        if "date" in column:
+            df = df.withColumn(column, f.col(column).cast("date"))
+
+    # Write to the database with specified options
+    df.repartition(10).write.format("jdbc").options(
+        url=db_properties["base_url"],
+        dbtable=domain_table_folder.name,
+        user=db_properties["user"],
+        password=db_properties["password"],
+        batchsize=200000,
+        queryTimeout=500,
+    ).mode("overwrite").save()
+
+
+# Main function to process the folders and upload tables
+def main(credential_path, input_folder):
+    # Load database properties from the credentials file
+    config = configparser.ConfigParser()
+    config.read(credential_path)
+    db_properties = config.defaults()
+
+    # Initialize SparkSession
+    spark = get_spark_session()
+
+    # Process each folder within the input folder
+    input_folder = Path(input_folder)
+    uploaded_tables = []
+    for folder in input_folder.glob("*"):
+        try:
+            if folder.is_dir() and folder.name in omop_timestamp_dict:
+                upload_omop_tables(spark, folder, db_properties)
+                uploaded_tables.append(folder.name)
+                print(f"Table: {folder.name} uploaded successfully")
+        except Exception as e:
+            print(f"Error uploading table {folder.name}: {e}")
+
+    print(f"Uploaded tables: {uploaded_tables}")
+
+
+# Argument parsing moved under __name__ == "__main__"
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Arguments for uploading OMOP tables")
+
+    parser.add_argument(
+        "-c",
+        "--credential_path",
+        required=True,
+        help="The path for your database credentials",
+    )
+
+    parser.add_argument(
+        "-i",
+        "--input_folder",
+        required=True,
+        help="Path to the input folder containing the OMOP tables",
+    )
+
+    args = parser.parse_args()
+
+    # Call the main function with parsed arguments
+    main(args.credential_path, args.input_folder)

cehrgpt-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Department of Biomedical Informatics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

cehrgpt-0.0.1.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.2
+Name: cehrgpt
+Version: 0.0.1
+Summary: CEHR-GPT: Generating Electronic Health Records with Chronological Patient Timelines
+Author-email: Chao Pang <chaopang229@gmail.com>, Xinzhuo Jiang <xj2193@cumc.columbia.edu>, Krishna Kalluri <kk3326@cumc.columbia.edu>, Elise Minto <em3697@cumc.columbia.edu>, Jason Patterson <jp3477@cumc.columbia.edu>, Nishanth Parameshwar Pavinkurve <np2689@cumc.columbia.edu>, Karthik Natarajan <kn2174@cumc.columbia.edu>
+License: MIT License
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: cehrbert==1.3.3
+Requires-Dist: openai==1.54.3
+Requires-Dist: optuna==4.0.0
+Requires-Dist: transformers==4.40.0
+Requires-Dist: tokenizers==0.19
+Requires-Dist: trl==0.11.4
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-subtests; extra == "dev"
+Requires-Dist: rootutils; extra == "dev"
+Requires-Dist: hypothesis; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Provides-Extra: flash-attn
+Requires-Dist: flash_attn; extra == "flash-attn"
+
+# CEHRGPT
+
+[![PyPI - Version](https://img.shields.io/pypi/v/cehrgpt)](https://pypi.org/project/cehrgpt/)
+![Python](https://img.shields.io/badge/-Python_3.11-blue?logo=python&logoColor=white)
+[![tests](https://github.com/knatarajan-lab/cehrgpt-public/actions/workflows/tests.yaml/badge.svg)](https://github.com/knatarajan-lab/cehrgpt-public/actions/workflows/tests.yml)
+[![license](https://img.shields.io/badge/License-MIT-green.svg?labelColor=gray)](https://github.com/knatarajan-lab/cehrgpt-public/blob/main/LICENSE)
+[![contributors](https://img.shields.io/github/contributors/knatarajan-lab/cehrgpt-public.svg)](https://github.com/knatarajan-lab/cehrgpt-public/graphs/contributors)
+
+## Description
+CEHRGPT is a synthetic data generation model developed to handle structured electronic health records (EHR) with enhanced privacy and reliability. It leverages state-of-the-art natural language processing techniques to create realistic, anonymized patient data that can be used for research and development without compromising patient privacy.
+
+## Features
+- **Synthetic Patient Data Generation**: Generates comprehensive patient profiles including demographics, medical history, treatment courses, and outcomes.
+- **Privacy-Preserving**: Implements techniques to ensure the generated data does not reveal identifiable information.
+- **Compatibility with OMOP**: Fully compatible with the OMOP common data model, allowing seamless integration with existing healthcare data systems.
+- **Extensible**: Designed to be adaptable to new datasets and different EHR systems.
+
+## Installation
+To install CEHRGPT, clone this repository and install the required dependencies.
+
+```bash
+git clone https://github.com/knatarajan-lab/cehrgpt-public.git
+cd cehrgpt-public
+pip install .
+```
+
+## Citation
+```
+@article{cehrgpt2024,
+  title={CEHRGPT: Synthetic Data Generation for Electronic Health Records},
+  author={Natarajan, K and others},
+  journal={arXiv preprint arXiv:2402.04400},
+  year={2024}
+}
+```

cehrgpt-0.0.1.dist-info/RECORD

@@ -0,0 +1,60 @@
+__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/cehrgpt_args.py,sha256=zPLp9Qjlq5PapWx3R15BNnyaX8zV3dxr4PuWj71r0Lg,3516
+cehrgpt/gpt_utils.py,sha256=bksHCXMX4j859VSv1Q284rVr4gn1Y8dCx4a_V-g4mug,10939
+cehrgpt/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/analysis/privacy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/analysis/privacy/attribute_inference.py,sha256=0ANVW0I5uvOl6IxQ15-vMVQd0mugOgSGReBUQQESImg,9368
+cehrgpt/analysis/privacy/attribute_inference_config.yml,sha256=hfLfpBlDqqsNOynpRHK414vV24edKA6ta-inmEhM2ao,103272
+cehrgpt/analysis/privacy/member_inference.py,sha256=a_-4rkYYffYl0ucnjK6uYy8jesupt8vDObIg3l-mp4M,5903
+cehrgpt/analysis/privacy/nearest_neighbor_inference.py,sha256=qoJgWW7VsUMzjMGpTaK84iY_QLOuF3HCYXAEKLZOZsU,6391
+cehrgpt/analysis/privacy/reid_inference.py,sha256=Pypd3QJXQNY8VljpnIEa5zeAbTZHMjQOazaL-9VsBGw,13955
+cehrgpt/analysis/privacy/utils.py,sha256=CRA4H9mPLBjMQGKzZ_x_3ro3tMap-NjsMDVqSOjHSVQ,8226
+cehrgpt/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/data/hf_cehrgpt_dataset.py,sha256=7hvjjqE8WInVuRvAtNkFI_J-xluFBv1Ij4TPTdUxPM4,2570
+cehrgpt/data/hf_cehrgpt_dataset_collator.py,sha256=RYw5Isrwa4sdyQQ3Nf3cu7xPDA3m-c5ecCFf_y1TJKY,20497
+cehrgpt/data/hf_cehrgpt_dataset_mapping.py,sha256=aQ0gsThOFhrh9ExpJhRmuiwN9ShIKheLgCIci-N7HOM,4305
+cehrgpt/generation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/generation/chatgpt_generation.py,sha256=SrnLwHLdNtnAOEg36gNjqfoT9yd12iyPgpZffL2AFJo,4428
+cehrgpt/generation/generate_batch_hf_gpt_sequence.py,sha256=-WLpKlulVVDJSdA2jXyp87gfLW4Q3aAtwULK8fDtn_E,11408
+cehrgpt/generation/omop_converter_batch.py,sha256=SDpWjqzi8dsgVzbbFes42GMdZEvrJ3sm4RbP5UpmIlk,25280
+cehrgpt/generation/omop_entity.py,sha256=Q5Sr0AlyuPAm1FRPfnJO13q-u1fqRgYVHXruZ9g4xNE,19400
+cehrgpt/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/models/config.py,sha256=xek4W_siO7WtMAKE7zDsENotsIE70F8dcW-PTC0kBKk,9700
+cehrgpt/models/hf_cehrgpt.py,sha256=YrHhT8c92xcOVTb6FjFQokyHrDOcXgEDMBs0BksSBpA,75739
+cehrgpt/models/hf_modeling_outputs.py,sha256=LaWa1jI6BRIKMEjWOy1QUeOfTur5y_p2c-JyuGVTdtw,10301
+cehrgpt/models/pretrained_embeddings.py,sha256=vLLVs17TLpXRqCVEWQxGGwPHkUJUO7laNTeBuyBK_yk,3238
+cehrgpt/models/special_tokens.py,sha256=-a7HPJBbdIH0qQ6B3CcRKqvpG6FZlm4nbVPTswGSJ4U,485
+cehrgpt/models/tokenization_hf_cehrgpt.py,sha256=jQR5aHjdHhS14nC1qnqDmybS1gpB27WK2-qVNz9cxW0,42156
+cehrgpt/omop/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/omop/condition_era.py,sha256=hPZALz2XaWnro_1bwIYNkI48foOJjueyg3CZ1BliCno,626
+cehrgpt/omop/observation_period.py,sha256=TRMgv5Ya2RaS2im7oQ6BLC_5JL9EJYNYR62ApxIuHvg,1211
+cehrgpt/omop/omop_argparse.py,sha256=WI_-vZGfPdZ8atIeB-CrpaPdkv07kDBabyEpaRZfl64,998
+cehrgpt/omop/omop_table_builder.py,sha256=6K_YYKyayDUBwxUdwaliI5tufpfIQqByDY5HeBbjHok,2742
+cehrgpt/omop/sample_omop_tables.py,sha256=2JZ8BNSvssceinwFanvuCRh-YlKrKn25U9w1pL79kQ0,2300
+cehrgpt/omop/queries/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/omop/queries/condition_era.py,sha256=LFB6vBAvshHJxtYIRkl7cfrF0kf7ay0piBKpmHBwrpE,2578
+cehrgpt/omop/queries/observation_period.py,sha256=fpzr5DMNw-QLoSwp2Iatfch88E3hyhZ75usiIdG3A0U,6410
+cehrgpt/runners/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/runners/gpt_runner_util.py,sha256=88HKSVj-ADGBCMo7C3znKSMPnAAALa1iU_6P6i9sD0M,3867
+cehrgpt/runners/hf_cehrgpt_finetune_runner.py,sha256=aGw87ZJuUIH196ryaZzt9D4hCAHVcDyKnvvdVPdipwc,31568
+cehrgpt/runners/hf_cehrgpt_pretrain_runner.py,sha256=6xulvnjwy6LDRPIL_zgsYH7sJMiXJ9AvFg3p2o35S6c,16510
+cehrgpt/runners/hf_gpt_runner_argument_dataclass.py,sha256=2l1X5bp1zckoFp0rQkxGptXyG8u3PgNw0dqYVDWLYjg,5155
+cehrgpt/runners/hyperparameter_search_util.py,sha256=i4qAb_22JO78l40MSyBPwDgAGuGc96efXmg_833cSSo,9044
+cehrgpt/time_to_event/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/time_to_event/time_to_event_model.py,sha256=tfXa24l_0q1TBZ68BPRrHRC_3KRWYxrWGIv4myJlIb8,8497
+cehrgpt/time_to_event/time_to_event_prediction.py,sha256=Ajesq2gSsILghWHCTLiiBhcyOCa7m6JPPMdi_xvBlR4,12624
+cehrgpt/time_to_event/time_to_event_utils.py,sha256=KN4hwGgxy2nJtO7osbYQBF3-HpmGUWefNfexzPYiEwc,1937
+cehrgpt/time_to_event/config/30_day_readmission.yaml,sha256=Hn5KnEXMtSV_CtCpmAU4wjkc0-gTXvniaH991TSbUXA,234
+cehrgpt/time_to_event/config/next_visit_type_prediction.yaml,sha256=WMj2ZutEvHKIMyGG51xtXaL6MyRANKvpg9xT8ouctLc,319
+cehrgpt/time_to_event/config/t2dm_hf.yaml,sha256=_oMQzh2eJTYzEaMOpmhAzbX-qmdsKlkORELL6HxOxHo,202
+cehrgpt/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cehrgpt/tools/ehrshot_benchmark.py,sha256=E-m_5srlYEw7Y7i9twIJWDvrkwNlop-6yZB-80FZid0,2667
+cehrgpt/tools/generate_pretrained_embeddings.py,sha256=lhFSacGv8bMld6qigKZN8Op8eXpFi0DsJuQbWKOWXqI,4160
+cehrgpt/tools/merge_synthetic_real_dataasets.py,sha256=O1dbQ32Le0t15fwymwAh9mfNVLEWuFwW53DNvESrWbY,7589
+cehrgpt/tools/upload_omop_tables.py,sha256=vdBAbkeAsGPA4NsyhNjelPVj3gS8yzmS1sKNM1Qk96g,3791
+cehrgpt-0.0.1.dist-info/LICENSE,sha256=LOfC32zkfUIdGm8e_098jPbt8OHKtNWymDzxn2pA9Zk,1093
+cehrgpt-0.0.1.dist-info/METADATA,sha256=BZrsoZe0Smn4JoA3cCI63fC4nBvOVrC9sgZ0Ct1NJsA,3388
+cehrgpt-0.0.1.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
+cehrgpt-0.0.1.dist-info/top_level.txt,sha256=akNCJBbMSLV8nkOzdVzdy13hMJ5CIQURnAS_YYEDVwA,17
+cehrgpt-0.0.1.dist-info/RECORD,,

cehrgpt-0.0.1.dist-info/WHEEL

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

cehrgpt-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+__init__
+cehrgpt