Initial commit: Gradio app and requirements

app.py

@@ -1,161 +1,52 @@
-import os
-import os
-import shutil
-import zipfile
-import pathlib
-import pandas as pd
 import gradio as gr
-import huggingface_hub as h
-from huggingface_hub import HfApi, Repository, create_repo, login
-import autogluon.tabular
-import getpass
-import shutil
-from git import Repo as GitRepo
-
-model_repo_id = "madhavkarthi/24679-HW2-tabular-autolguon-predictor"
-zip_filename  = "autogluon_predictor_dir.zip"
-cache_dir = pathlib.Path("hf_assests")
-extract_dir = cache_dir / "predictor_native"
-
-def prepare_predictor_dir() -> str:
-    cache_dir.mkdir(parents=True, exist_ok=True)
-    local_zip = h.hf_hub_download(
-        repo_id=model_repo_id,
-        filename=zip_filename,
-        repo_type="model",
-        local_dir=str(cache_dir),
-        local_dir_use_symlinks=False,
-    )
-    if extract_dir.exists():
-        shutil.rmtree(extract_dir)
-    extract_dir.mkdir(parents=True, exist_ok=True)
-    with zipfile.ZipFile(local_zip, "r") as zf:
-        zf.extractall(str(extract_dir))
-    contents = list(extract_dir.iterdir())
-    predictor_root = contents[0] if (len(contents) == 1 and contents[0].is_dir()) else extract_dir
-    return str(predictor_root)
-
-predictor_dir = prepare_predictor_dir()
-predictor = autogluon.tabular.TabularPredictor.load(predictor_dir, require_py_version_match=False)
-
-def do_predict(right_hand_notes, left_hand_notes, measures, Key_Center, marking):
-
-    row = {
-        feature_col[0]: int(right_hand_notes),
-        feature_col[1]: int(left_hand_notes),
-        feature_col[2]: int(measures),
-        feature_col[3]: int(Key_Center),
-        feature_col[4]: int(marking),
-    }
-    X = pd.DataFrame([row], columns=feature_col)
-
-    pred_series = predictor.predict(X)
-    raw_pred = pred_series.iloc[0]
-
-    try:
-        proba = predictor.predict_proba(X)
-        if isinstance(proba, pd.Series):
-            proba = proba.to_frame().T
-    except Exception:
-        proba = None
-
-    pred_label = human_label(raw_pred)
-
-    proba_dict = None
-    if proba is not None:
-        row0 = proba.iloc[0]
-        tmp = {}
-        for cls, val in row0.items():
-            key = human_label(cls)
-            tmp[key] = float(val) + float(tmp.get(key, 0.0))
-        proba_dict = dict(sorted(tmp.items(), key=lambda kv: kv[1], reverse=True))
+from autogluon.tabular import TabularPredictor
+import pandas as pd
 
-    return pred_label, proba_dict
+# Load the model from the `model/` folder in this repo
+predictor = TabularPredictor.load("model/")
 
 key_center_mapping = {
     0: "A", 1: "Bb", 2: "B", 3: "C", 4: "Db", 5: "D",
     6: "Eb", 7: "E", 8: "F", 9: "Gb", 10: "G", 11: "Ab"
 }
-
 marking_mapping = {
-    0: "Minuet", 1: "Allegro", 2: "Andante", 3: "Moderato",
-    4: "Allegretto", 5: "Dance"
+    0: "Minuet", 1: "Allegro", 2: "Andante",
+    3: "Moderato", 4: "Allegretto", 5: "Dance"
 }
 
+def predict_composer(rh, lh, measures, key_center, marking):
+    df = pd.DataFrame({
+        'right hand notes': [rh],
+        'left hand notes': [lh],
+        'measures': [measures],
+        'Key Center': [key_center],
+        'marking': [marking]
+    })
+    pred = predictor.predict(df)[0]
+    probs = predictor.predict_proba(df).iloc[0].to_dict()
+    return pred, probs
+
+examples = [
+    [108, 82, 16, 3, 1],
+    [196, 136, 29, 2, 2],
+    [96, 49, 13, 2, 4],
+    [481, 561, 31, 5, 5],
+    [174, 129, 31, 2, 1],
+]
 
 with gr.Blocks() as demo:
     gr.Markdown("# Classical Music Composer Classifier")
-    gr.Markdown(
-        "Predict whether a classical piano piece was composed by **Mozart** or **Beethoven** "
-        "based on musical characteristics."
-    )
-
+    gr.Markdown("Predict whether a piece was composed by **Mozart** or **Beethoven**.")
     with gr.Row():
-        right_hand_input = gr.Number(
-            value=150,
-            precision=0,
-            label="Right Hand Notes",
-            info="Number of notes played by right hand"
-        )
-        left_hand_input = gr.Number(
-            value=100,
-            precision=0,
-            label="Left Hand Notes",
-            info="Number of notes played by left hand"
-        )
-        measures_input = gr.Number(
-            value=20,
-            precision=0,
-            label="Measures",
-            info="Number of musical measures"
-        )
-
+        rh = gr.Number(150, label="Right Hand Notes")
+        lh = gr.Number(100, label="Left Hand Notes")
+        measures = gr.Number(20, label="Measures")
     with gr.Row():
-        key_center_input = gr.Dropdown(
-            choices=[(f"{v} ({k})", k) for k, v in key_center_mapping.items()],
-            value=3,
-            label="Key Center",
-            info="Musical key of the piece"
-        )
-        marking_input = gr.Dropdown(
-            choices=[(f"{v} ({k})", k) for k, v in marking_mapping.items()],
-            value=1,
-            label="Musical Marking",
-            info="Tempo/style marking of the piece"
-        )
-
-    predicted_composer_output = gr.Textbox(label="Predicted Composer")
-    proba_output = gr.Label(num_top_classes=2, label="Prediction Probabilities")
-
-    inputs_for_predict = [
-        right_hand_input, left_hand_input, measures_input,
-        key_center_input, marking_input
-    ]
-    outputs_for_predict = [predicted_composer_output, proba_output]
-
-    for comp in inputs_for_predict:
-        comp.change(
-            fn=do_predict,
-            inputs=inputs_for_predict,
-            outputs=outputs_for_predict
-        )
-
-    gr.Examples(
-        examples=examples,
-        inputs=inputs_for_predict,
-        label="Example Pieces",
-        examples_per_page=5,
-        cache_examples=False,
-    )
-
-    gr.Markdown("""
-    ### About the Features:
-    - **Right Hand Notes**: Count of notes played by the right hand
-    - **Left Hand Notes**: Count of notes played by the left hand
-    - **Measures**: Total number of musical measures in the piece
-    - **Key Center**: The musical key (A=0, Bb=1, B=2, C=3, Db=4, D=5, Eb=6, E=7, F=8, Gb=9, G=10, Ab=11)
-    - **Musical Marking**: Tempo/style indication (Minuet=0, Allegro=1, Andante=2, Moderato=3, Allegretto=4, Dance=5)
-    """)
-
-if __name__ == "__main__":
+        key_center = gr.Dropdown(list(key_center_mapping.keys()), value=3, label="Key Center")
+        marking = gr.Dropdown(list(marking_mapping.keys()), value=1, label="Marking")
+    out_label = gr.Textbox(label="Predicted Composer")
+    out_probs = gr.Label(num_top_classes=2, label="Probabilities")
+    for inp in [rh, lh, measures, key_center, marking]:
+        inp.change(fn=predict_composer, inputs=[rh, lh, measures, key_center, marking], outputs=[out_label, out_probs])
+    gr.Examples(examples, inputs=[rh, lh, measures, key_center, marking], outputs=[out_label, out_probs])
     demo.launch()

requirements.txt

@@ -1,6 +1,4 @@
-gradio
+gradio>=3.0
+autogluon.tabular
 pandas
-numpy
-pillow
-autogluon.multimodal
 huggingface_hub