cehrbert-data 0.0.1__py3-none-any.whl

cehrbert_data/apps/generate_included_concept_list.py

@@ -0,0 +1,116 @@
+"""
+This module generates a qualified concept list by processing patient event data across various.
+
+domain tables (e.g., condition_occurrence, procedure_occurrence, drug_exposure) and applying a
+patient frequency filter to retain concepts linked to a minimum number of patients.
+
+Key Functions:
+    - preprocess_domain_table: Preprocesses domain tables to prepare for event extraction.
+    - join_domain_tables: Joins multiple domain tables into a unified DataFrame.
+    - main: Coordinates the entire process of reading domain tables, applying frequency filters,
+      and saving the qualified concept list.
+
+Command-line Arguments:
+    - input_folder: Directory containing the input data.
+    - output_folder: Directory where the qualified concept list will be saved.
+    - min_num_of_patients: Minimum number of patients linked to a concept for it to be included.
+    - with_drug_rollup: Boolean flag indicating whether drug concept rollups should be applied.
+"""
+
+import os
+
+from pyspark.sql import SparkSession
+from pyspark.sql import functions as F
+
+from cehrbert_data.config.output_names import QUALIFIED_CONCEPT_LIST_PATH
+from cehrbert_data.const.common import MEASUREMENT
+from cehrbert_data.utils.spark_utils import join_domain_tables, preprocess_domain_table
+
+DOMAIN_TABLE_LIST = ["condition_occurrence", "procedure_occurrence", "drug_exposure"]
+
+
+def main(input_folder, output_folder, min_num_of_patients, with_drug_rollup: bool = True):
+    """
+    Main function to generate a qualified concept list based on patient event data from multiple.
+
+    domain tables.
+
+    Args:
+        input_folder (str): The directory where the input data is stored.
+        output_folder (str): The directory where the output (qualified concept list) will be saved.
+        min_num_of_patients (int): Minimum number of patients that a concept must be linked to for
+        nclusion.
+        with_drug_rollup (bool): If True, applies drug rollup logic to the drug_exposure domain.
+
+    The function processes patient event data across various domain tables, excludes low-frequency
+    concepts, and saves the filtered concepts to a specified output folder.
+    """
+    spark = SparkSession.builder.appName("Generate concept list").getOrCreate()
+
+    domain_tables = []
+    # Exclude measurement from domain_table_list if exists because we need to process measurement
+    # in a different way
+    for domain_table_name in DOMAIN_TABLE_LIST:
+        if domain_table_name != MEASUREMENT:
+            domain_tables.append(
+                preprocess_domain_table(
+                    spark,
+                    input_folder,
+                    domain_table_name,
+                    with_drug_rollup=with_drug_rollup,
+                )
+            )
+
+    # Union all domain table records
+    patient_events = join_domain_tables(domain_tables)
+
+    # Filter out concepts that are linked to less than 100 patients
+    qualified_concepts = (
+        patient_events.where("visit_occurrence_id IS NOT NULL")
+        .groupBy("standard_concept_id")
+        .agg(F.countDistinct("person_id").alias("freq"))
+        .where(F.col("freq") >= min_num_of_patients)
+    )
+
+    qualified_concepts.write.mode("overwrite").parquet(os.path.join(output_folder, QUALIFIED_CONCEPT_LIST_PATH))
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Arguments for generate concept list to be included")
+    parser.add_argument(
+        "-i",
+        "--input_folder",
+        dest="input_folder",
+        action="store",
+        help="The path for your input_folder where the raw data is",
+        required=True,
+    )
+    parser.add_argument(
+        "-o",
+        "--output_folder",
+        dest="output_folder",
+        action="store",
+        help="The path for your output_folder",
+        required=True,
+    )
+    parser.add_argument(
+        "--min_num_of_patients",
+        dest="min_num_of_patients",
+        action="store",
+        type=int,
+        default=0,
+        help="Min no.of patients linked to concepts to be included",
+        required=False,
+    )
+    parser.add_argument("--with_drug_rollup", dest="with_drug_rollup", action="store_true")
+
+    ARGS = parser.parse_args()
+
+    main(
+        ARGS.input_folder,
+        ARGS.output_folder,
+        ARGS.min_num_of_patients,
+        ARGS.with_drug_rollup,
+    )

cehrbert_data/apps/generate_information_content.py

@@ -0,0 +1,131 @@
+"""
+This module generates an information content table based on a list of domain tables from OMOP data.
+
+It processes patient event data, calculates the frequency of each concept, and computes information
+conten using the concept ancestor hierarchy. The results are written to a specified output path.
+
+Key Functions:
+    - preprocess_domain_table: Preprocess the domain tables for analysis.
+    - join_domain_tables: Join multiple domain tables to generate a unified patient event table.
+    - main: Orchestrates the process of reading input data, calculating concept frequencies,
+      and generating the information content table.
+
+Command-line Arguments:
+    - input_folder: The folder containing the raw OMOP domain data.
+    - output_folder: The folder where the results will be stored.
+    - domain_table_list: A list of OMOP domain tables to include in the analysis.
+    - date_filter: Optional date filter for processing the data.
+"""
+
+import datetime
+import logging
+import os
+
+from pyspark.sql import SparkSession
+from pyspark.sql import functions as F
+
+from cehrbert_data.config.output_names import INFORMATION_CONTENT_DATA_PATH
+from cehrbert_data.const.common import CONCEPT_ANCESTOR
+from cehrbert_data.utils.spark_utils import join_domain_tables, preprocess_domain_table, validate_table_names
+
+
+def main(input_folder, output_folder, domain_table_list, date_filter):
+    """Create the information content table.
+
+    Keyword arguments:
+    domain_tables -- the array containing the OMOP domain tables except visit_occurrence
+    concept_id_frequency_output -- the path for writing the concept frequency output
+
+    This function creates the information content table based on the given domain tables
+    """
+
+    spark = SparkSession.builder.appName("Generate the information content table").getOrCreate()
+
+    logger = logging.getLogger(__name__)
+    logger.info(
+        "input_folder: %s\noutput_folder: %s\ndomain_table_list: %s\ndate_filter: %s",
+        input_folder,
+        output_folder,
+        domain_table_list,
+        date_filter,
+    )
+
+    concept_ancestor = preprocess_domain_table(spark, input_folder, CONCEPT_ANCESTOR)
+    domain_tables = []
+    for domain_table_name in domain_table_list:
+        domain_tables.append(preprocess_domain_table(spark, input_folder, domain_table_name))
+
+    patient_events = join_domain_tables(domain_tables)
+
+    # Remove all concept_id records
+    patient_events = patient_events.where("standard_concept_id <> 0")
+
+    # Get the total count
+    total_count = patient_events.distinct().count()
+
+    # Count the frequency of each concept
+    concept_frequency = patient_events.distinct().groupBy("standard_concept_id").count()
+
+    # left join b/w descendent_concept_id and the standard_concept_id in the concept freq table
+    freq_df = (
+        concept_frequency.join(
+            concept_ancestor,
+            F.col("descendant_concept_id") == F.col("standard_concept_id"),
+        )
+        .groupBy("ancestor_concept_id")
+        .sum("count")
+        .withColumnRenamed("ancestor_concept_id", "concept_id")
+        .withColumnRenamed("sum(count)", "count")
+    )
+
+    # Calculate information content for each concept
+    information_content = freq_df.withColumn("information_content", (-F.log(F.col("count") / total_count))).withColumn(
+        "probability", F.col("count") / total_count
+    )
+
+    information_content.write.mode("overwrite").parquet(os.path.join(output_folder, INFORMATION_CONTENT_DATA_PATH))
+
+
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(description="Arguments for generate training data for Bert")
+    parser.add_argument(
+        "-i",
+        "--input_folder",
+        dest="input_folder",
+        action="store",
+        help="The path for your input_folder where the raw data is",
+        required=True,
+    )
+    parser.add_argument(
+        "-o",
+        "--output_folder",
+        dest="output_folder",
+        action="store",
+        help="The path for your output_folder",
+        required=True,
+    )
+    parser.add_argument(
+        "-tc",
+        "--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(
+        "-d",
+        "--date_filter",
+        dest="date_filter",
+        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
+        action="store",
+        required=False,
+        default="2018-01-01",
+    )
+
+    ARGS = parser.parse_args()
+
+    main(ARGS.input_folder, ARGS.output_folder, ARGS.domain_table_list, ARGS.date_filter)

cehrbert_data/apps/generate_required_labs.py

@@ -0,0 +1,112 @@
+import argparse
+import os
+
+from pyspark.sql import SparkSession
+from pyspark.sql import functions as F
+from pyspark.sql.window import Window
+
+from cehrbert_data.const.common import CONCEPT, MEASUREMENT, REQUIRED_MEASUREMENT
+from cehrbert_data.utils.spark_utils import preprocess_domain_table
+
+
+def main(input_folder, output_folder, num_of_numeric_labs, num_of_categorical_labs):
+    spark = SparkSession.builder.appName("Generate required labs").getOrCreate()
+
+    # Load measurement as a dataframe in pyspark
+    measurement = preprocess_domain_table(spark, input_folder, MEASUREMENT)
+    concept = preprocess_domain_table(spark, input_folder, CONCEPT)
+
+    # Create the local measurement view
+    measurement.createOrReplaceTempView("measurement")
+
+    # Create the local concept view
+    concept.createOrReplaceTempView("concept")
+
+    popular_labs = spark.sql(
+        """
+        SELECT
+            m.measurement_concept_id,
+            c.concept_name,
+            COUNT(*) AS freq,
+            SUM(CASE WHEN m.value_as_number IS NOT NULL THEN 1 ELSE 0 END) / COUNT(*) AS numeric_percentage,
+            SUM(CASE WHEN m.value_as_concept_id IS NOT NULL AND m.value_as_concept_id <> 0 THEN 1 ELSE 0 END) / COUNT(*) AS categorical_percentage
+        FROM measurement AS m
+        JOIN concept AS c
+            ON m.measurement_concept_id = c.concept_id
+        WHERE m.measurement_concept_id <> 0
+        GROUP BY m.measurement_concept_id, c.concept_name
+        ORDER BY COUNT(*) DESC
+    """
+    )
+
+    # Cache the dataframe for faster computation in the below transformations
+    popular_labs.cache()
+
+    popular_numeric_labs = (
+        popular_labs.withColumn("is_numeric", F.col("numeric_percentage") >= 0.5)
+        .where("is_numeric")
+        .withColumn("rn", F.row_number().over(Window.orderBy(F.desc("freq"))))
+        .where(F.col("rn") <= num_of_numeric_labs)
+        .drop("rn")
+    )
+
+    popular_categorical_labs = (
+        popular_labs.withColumn("is_categorical", F.col("categorical_percentage") >= 0.5)
+        .where("is_categorical")
+        .withColumn("is_numeric", ~F.col("is_categorical"))
+        .withColumn("rn", F.row_number().over(Window.orderBy(F.desc("freq"))))
+        .where(F.col("rn") <= num_of_categorical_labs)
+        .drop("is_categorical")
+        .drop("rn")
+    )
+
+    popular_numeric_labs.unionAll(popular_categorical_labs).write.mode("overwrite").parquet(
+        os.path.join(output_folder, REQUIRED_MEASUREMENT)
+    )
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Arguments for generate " "required labs to be included")
+    parser.add_argument(
+        "-i",
+        "--input_folder",
+        dest="input_folder",
+        action="store",
+        help="The path for your input_folder where the raw data is",
+        required=True,
+    )
+    parser.add_argument(
+        "-o",
+        "--output_folder",
+        dest="output_folder",
+        action="store",
+        help="The path for your output_folder",
+        required=True,
+    )
+    parser.add_argument(
+        "--num_of_numeric_labs",
+        dest="num_of_numeric_labs",
+        action="store",
+        type=int,
+        default=100,
+        help="The top most popular numeric labs to be included",
+        required=False,
+    )
+    parser.add_argument(
+        "--num_of_categorical_labs",
+        dest="num_of_categorical_labs",
+        action="store",
+        type=int,
+        default=100,
+        help="The top most popular categorical labs to be included",
+        required=False,
+    )
+
+    ARGS = parser.parse_args()
+
+    main(
+        ARGS.input_folder,
+        ARGS.output_folder,
+        ARGS.num_of_numeric_labs,
+        ARGS.num_of_categorical_labs,
+    )

cehrbert_data/apps/generate_training_data.py

@@ -0,0 +1,337 @@
+import argparse
+import datetime
+import logging
+import os
+import shutil
+
+from pyspark.sql import SparkSession
+from pyspark.sql import functions as F
+from pyspark.sql.window import Window
+
+from cehrbert_data.const.common import DEATH, MEASUREMENT, PERSON, REQUIRED_MEASUREMENT, VISIT_OCCURRENCE
+from cehrbert_data.decorators.patient_event_decorator import AttType
+from cehrbert_data.utils.spark_utils import (
+    create_sequence_data,
+    create_sequence_data_with_att,
+    join_domain_tables,
+    preprocess_domain_table,
+    process_measurement,
+    validate_table_names,
+)
+
+
+def main(
+    input_folder,
+    output_folder,
+    domain_table_list,
+    date_filter,
+    include_visit_type,
+    is_new_patient_representation,
+    exclude_visit_tokens,
+    is_classic_bert,
+    include_prolonged_stay,
+    include_concept_list: bool,
+    gpt_patient_sequence: bool,
+    apply_age_filter: bool,
+    include_death: bool,
+    att_type: AttType,
+    include_sequence_information_content: bool = False,
+    exclude_demographic: bool = False,
+    use_age_group: bool = False,
+    with_drug_rollup: bool = True,
+    include_inpatient_hour_token: bool = False,
+    continue_from_events: bool = False,
+):
+    spark = SparkSession.builder.appName("Generate CEHR-BERT Training Data").getOrCreate()
+
+    logger = logging.getLogger(__name__)
+    logger.info(
+        f"input_folder: {input_folder}\n"
+        f"output_folder: {output_folder}\n"
+        f"domain_table_list: {domain_table_list}\n"
+        f"date_filter: {date_filter}\n"
+        f"include_visit_type: {include_visit_type}\n"
+        f"is_new_patient_representation: {is_new_patient_representation}\n"
+        f"exclude_visit_tokens: {exclude_visit_tokens}\n"
+        f"is_classic_bert: {is_classic_bert}\n"
+        f"include_prolonged_stay: {include_prolonged_stay}\n"
+        f"include_concept_list: {include_concept_list}\n"
+        f"gpt_patient_sequence: {gpt_patient_sequence}\n"
+        f"apply_age_filter: {apply_age_filter}\n"
+        f"include_death: {include_death}\n"
+        f"att_type: {att_type}\n"
+        f"exclude_demographic: {exclude_demographic}\n"
+        f"use_age_group: {use_age_group}\n"
+        f"with_drug_rollup: {with_drug_rollup}\n"
+    )
+
+    domain_tables = []
+    for domain_table_name in domain_table_list:
+        if domain_table_name != MEASUREMENT:
+            domain_tables.append(
+                preprocess_domain_table(
+                    spark,
+                    input_folder,
+                    domain_table_name,
+                    with_drug_rollup=with_drug_rollup,
+                )
+            )
+
+    visit_occurrence = preprocess_domain_table(spark, input_folder, VISIT_OCCURRENCE)
+    visit_occurrence = visit_occurrence.select(
+        "visit_occurrence_id",
+        "visit_start_date",
+        "visit_start_datetime",
+        "visit_end_date",
+        "visit_concept_id",
+        "person_id",
+        "discharged_to_concept_id",
+    )
+    person = preprocess_domain_table(spark, input_folder, PERSON)
+    birth_datetime_udf = F.coalesce("birth_datetime", F.concat("year_of_birth", F.lit("-01-01")).cast("timestamp"))
+    person = person.select(
+        "person_id",
+        birth_datetime_udf.alias("birth_datetime"),
+        "race_concept_id",
+        "gender_concept_id",
+    )
+
+    visit_occurrence_person = visit_occurrence.join(person, "person_id").withColumn(
+        "age",
+        F.ceil(F.months_between(F.col("visit_start_date"), F.col("birth_datetime")) / F.lit(12)),
+    )
+    visit_occurrence_person = visit_occurrence_person.drop("birth_datetime")
+
+    death = preprocess_domain_table(spark, input_folder, DEATH) if include_death else None
+
+    patient_events = join_domain_tables(domain_tables)
+
+    if include_concept_list and patient_events:
+        column_names = patient_events.schema.fieldNames()
+        # Filter out concepts
+        qualified_concepts = preprocess_domain_table(spark, input_folder, "qualified_concept_list").select(
+            "standard_concept_id"
+        )
+
+        patient_events = patient_events.join(qualified_concepts, "standard_concept_id").select(column_names)
+
+    # Process the measurement table if exists
+    if MEASUREMENT in domain_table_list:
+        measurement = preprocess_domain_table(spark, input_folder, MEASUREMENT)
+        required_measurement = preprocess_domain_table(spark, input_folder, REQUIRED_MEASUREMENT)
+        # The select is necessary to make sure the order of the columns is the same as the
+        # original dataframe, otherwise the union might use the wrong columns
+        scaled_measurement = process_measurement(spark, measurement, required_measurement, output_folder)
+
+        if patient_events:
+            # Union all measurement records together with other domain records
+            patient_events = patient_events.unionByName(scaled_measurement)
+        else:
+            patient_events = scaled_measurement
+
+    patient_events = (
+        patient_events.join(visit_occurrence_person, "visit_occurrence_id")
+        .select(
+            [patient_events[fieldName] for fieldName in patient_events.schema.fieldNames()]
+            + ["visit_concept_id", "age"]
+        )
+        .withColumn("cohort_member_id", F.col("person_id"))
+    )
+
+    # Apply the age security measure
+    # We only keep the patient records, whose corresponding age is less than 90
+    if apply_age_filter:
+        patient_events = patient_events.where(F.col("age") < 90)
+
+    if not continue_from_events:
+        patient_events.write.mode("overwrite").parquet(os.path.join(output_folder, "all_patient_events"))
+
+    patient_events = spark.read.parquet(os.path.join(output_folder, "all_patient_events"))
+
+    if is_new_patient_representation:
+        sequence_data = create_sequence_data_with_att(
+            patient_events,
+            visit_occurrence_person,
+            date_filter=date_filter,
+            include_visit_type=include_visit_type,
+            exclude_visit_tokens=exclude_visit_tokens,
+            patient_demographic=person if gpt_patient_sequence else None,
+            death=death,
+            att_type=att_type,
+            exclude_demographic=exclude_demographic,
+            use_age_group=use_age_group,
+            include_inpatient_hour_token=include_inpatient_hour_token,
+        )
+    else:
+        sequence_data = create_sequence_data(
+            patient_events,
+            date_filter=date_filter,
+            include_visit_type=include_visit_type,
+            classic_bert_seq=is_classic_bert,
+        )
+
+    if include_prolonged_stay:
+        udf = F.when(
+            F.col("visit_concept_id").isin([9201, 262, 9203]),
+            F.coalesce(
+                (F.datediff("visit_end_date", "visit_start_date") > 7).cast("int"),
+                F.lit(0),
+            ),
+        ).otherwise(F.lit(0))
+        visit_occurrence = preprocess_domain_table(spark, input_folder, VISIT_OCCURRENCE)
+        visit_occurrence = (
+            visit_occurrence.withColumn("prolonged_length_stay", udf)
+            .select("person_id", "prolonged_length_stay")
+            .withColumn(
+                "prolonged_length_stay",
+                F.max("prolonged_length_stay").over(Window.partitionBy("person_id")),
+            )
+            .distinct()
+        )
+        sequence_data = sequence_data.join(visit_occurrence, "person_id")
+
+    if include_sequence_information_content:
+        concept_df = patient_events.select("person_id", F.col("standard_concept_id").alias("concept_id"))
+        concept_freq = (
+            concept_df.groupBy("concept_id")
+            .count()
+            .withColumn("prob", F.col("count") / F.sum("count").over(Window.partitionBy()))
+            .withColumn("ic", -F.log("prob"))
+        )
+
+        patient_ic_df = concept_df.join(concept_freq, "concept_id").groupby("person_id").agg(F.mean("ic").alias("ic"))
+
+        sequence_data = sequence_data.join(patient_ic_df, "person_id")
+
+    patient_splits_folder = os.path.join(input_folder, "patient_splits")
+    if os.path.exists(patient_splits_folder):
+        patient_splits = spark.read.parquet(patient_splits_folder)
+        sequence_data.join(patient_splits, "person_id").write.mode("overwrite").parquet(
+            os.path.join(output_folder, "patient_sequence", "temp")
+        )
+        sequence_data = spark.read.parquet(os.path.join(output_folder, "patient_sequence", "temp"))
+        sequence_data.where('split="train"').write.mode("overwrite").parquet(
+            os.path.join(output_folder, "patient_sequence/train")
+        )
+        sequence_data.where('split="test"').write.mode("overwrite").parquet(
+            os.path.join(output_folder, "patient_sequence/test")
+        )
+        shutil.rmtree(os.path.join(output_folder, "patient_sequence", "temp"))
+    else:
+        sequence_data.write.mode("overwrite").parquet(os.path.join(output_folder, "patient_sequence"))
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Arguments for generate training data for Bert")
+    parser.add_argument(
+        "-i",
+        "--input_folder",
+        dest="input_folder",
+        action="store",
+        help="The path for your input_folder where the raw data is",
+        required=True,
+    )
+    parser.add_argument(
+        "-o",
+        "--output_folder",
+        dest="output_folder",
+        action="store",
+        help="The path for your output_folder",
+        required=True,
+    )
+    parser.add_argument(
+        "-tc",
+        "--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(
+        "-d",
+        "--date_filter",
+        dest="date_filter",
+        type=lambda s: datetime.datetime.strptime(s, "%Y-%m-%d"),
+        action="store",
+        required=False,
+        default="2018-01-01",
+    )
+    parser.add_argument(
+        "-iv",
+        "--include_visit_type",
+        dest="include_visit_type",
+        action="store_true",
+        help="Specify whether to include visit types for generating the training data",
+    )
+    parser.add_argument(
+        "-ip",
+        "--is_new_patient_representation",
+        dest="is_new_patient_representation",
+        action="store_true",
+        help="Specify whether to generate the sequence of EHR records using the new patient " "representation",
+    )
+    parser.add_argument(
+        "-ib",
+        "--is_classic_bert_sequence",
+        dest="is_classic_bert_sequence",
+        action="store_true",
+        help="Specify whether to generate the sequence of EHR records using the classic BERT " "sequence",
+    )
+    parser.add_argument(
+        "-ev",
+        "--exclude_visit_tokens",
+        dest="exclude_visit_tokens",
+        action="store_true",
+        help="Specify whether or not to exclude the VS and VE tokens",
+    )
+    parser.add_argument(
+        "--include_prolonged_length_stay",
+        dest="include_prolonged_stay",
+        action="store_true",
+        help="Specify whether or not to include the data for the second learning objective for " "Med-BERT",
+    )
+    parser.add_argument("--include_concept_list", dest="include_concept_list", action="store_true")
+    parser.add_argument("--gpt_patient_sequence", dest="gpt_patient_sequence", action="store_true")
+    parser.add_argument("--apply_age_filter", dest="apply_age_filter", action="store_true")
+    parser.add_argument("--include_death", dest="include_death", action="store_true")
+    parser.add_argument("--exclude_demographic", dest="exclude_demographic", action="store_true")
+    parser.add_argument("--use_age_group", dest="use_age_group", action="store_true")
+    parser.add_argument("--with_drug_rollup", dest="with_drug_rollup", action="store_true")
+    parser.add_argument(
+        "--include_inpatient_hour_token",
+        dest="include_inpatient_hour_token",
+        action="store_true",
+    )
+    parser.add_argument("--continue_from_events", dest="continue_from_events", action="store_true")
+    parser.add_argument(
+        "--att_type",
+        dest="att_type",
+        action="store",
+        choices=[e.value for e in AttType],
+    )
+
+    ARGS = parser.parse_args()
+
+    main(
+        ARGS.input_folder,
+        ARGS.output_folder,
+        ARGS.domain_table_list,
+        ARGS.date_filter,
+        ARGS.include_visit_type,
+        ARGS.is_new_patient_representation,
+        ARGS.exclude_visit_tokens,
+        ARGS.is_classic_bert_sequence,
+        ARGS.include_prolonged_stay,
+        ARGS.include_concept_list,
+        ARGS.gpt_patient_sequence,
+        ARGS.apply_age_filter,
+        ARGS.include_death,
+        AttType(ARGS.att_type),
+        exclude_demographic=ARGS.exclude_demographic,
+        use_age_group=ARGS.use_age_group,
+        with_drug_rollup=ARGS.with_drug_rollup,
+        include_inpatient_hour_token=ARGS.include_inpatient_hour_token,
+        continue_from_events=ARGS.continue_from_events,
+    )