import os # For filesystem operations import shutil # For directory cleanup import zipfile # For extracting model archives import pathlib # For path manipulations import pandas # For tabular data handling import gradio # For interactive UI import huggingface_hub # For downloading model assets import autogluon.tabular # For loading and running AutoGluon predictors # Settings MODEL_REPO_ID = "ccm/2024-24679-tabular-autolguon-predictor" ZIP_FILENAME = "autogluon_predictor_dir.zip" CACHE_DIR = pathlib.Path("hf_assets") EXTRACT_DIR = CACHE_DIR / "predictor_native" # Feature column names and target column names FEATURE_COLS = [ "About how many hours per week do you spend listening to music?", "Approximately how many songs are in your music library?", "Approximately how many playlists have you created yourself?", "How often do you share music with others?", "Which decade of music do you listen to most?", "How often do you attend live music events?", "Do you prefer songs with lyrics or instrumental music?", ] TARGET_COL = "Do you usually listen to music alone or with others?" # Encoding for likert questions LIKERT5_LABELS = ["Never", "Rarely", "Sometimes", "Often", "Very Often"] LIKERT5_MAP = {label: idx for idx, label in enumerate(LIKERT5_LABELS)} # Encoding for decade questions DECADE_LABELS = ["1970s and before", "1980s", "1990s", "2000s", "2010s", "2020s"] DECADE_MAP = {label: idx for idx, label in enumerate(DECADE_LABELS)} # Encoding for lyrics questions LYRICS_LABELS = ["Lyrics", "Instrumental", "Both equally"] LYRICS_MAP = {label: idx for idx, label in enumerate(LYRICS_LABELS)} # Encoding for outcome questions OUTCOME_LABELS = { 0: "Mostly Alone", 1: "Mostly With Others", } # Download & load the native predictor def _prepare_predictor_dir() -> str: CACHE_DIR.mkdir(parents=True, exist_ok=True) local_zip = huggingface_hub.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) # A mapping utility to make it easier to encode the variables def _human_label(c): try: ci = int(c) if ci in OUTCOME_LABELS: return OUTCOME_LABELS[ci] except Exception: pass if c in OUTCOME_LABELS: return OUTCOME_LABELS[c] return str(c) # This functions takes all of our features,e ncodes this accordingly, and performs a predictions def do_predict(hours_per_week, num_songs, num_playlists, share_label, decade_label, live_events_label, lyrics_label): share_code = LIKERT5_MAP[share_label] decade_code = DECADE_MAP[decade_label] live_events_code = LIKERT5_MAP[live_events_label] lyrics_code = LYRICS_MAP[lyrics_label] row = { FEATURE_COLS[0]: float(hours_per_week), FEATURE_COLS[1]: int(num_songs), FEATURE_COLS[2]: int(num_playlists), FEATURE_COLS[3]: int(share_code), FEATURE_COLS[4]: int(decade_code), FEATURE_COLS[5]: int(live_events_code), FEATURE_COLS[6]: int(lyrics_code), } X = pandas.DataFrame([row], columns=FEATURE_COLS) pred_series = PREDICTOR.predict(X) raw_pred = pred_series.iloc[0] try: proba = PREDICTOR.predict_proba(X) if isinstance(proba, pandas.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)) df_out = pandas.DataFrame([{ "Predicted outcome": pred_label, "Confidence (%)": round((proba_dict.get(pred_label, 1.0) if proba_dict else 1.0) * 100, 2), }]) md = f"**Prediction:** {pred_label}" if proba_dict: md += f" \n**Confidence:** {round(proba_dict.get(pred_label, 0.0) * 100, 2)}%" return proba_dict # Representative examples EXAMPLES = [ [5.0, 300, 3, "Rarely", "2010s", "Rarely", "Lyrics"], [18.0, 1500, 25, "Often", "2000s", "Often", "Both equally"], [12.0, 8000, 40, "Sometimes", "1990s", "Sometimes", "Instrumental"], [4.0, 120, 1, "Never", "1970s and before", "Rarely", "Lyrics"], [22.0, 500, 10, "Very Often", "2020s", "Very Often", "Lyrics"], ] # Gradio UI with gradio.Blocks() as demo: # Provide an introduction gradio.Markdown("# Will they make you listen?") gradio.Markdown(""" This is a simple app that demonstrates builds on the datasets and models we've been making in class to answer an important question about your friends: are they going to make you listen to their music? To use hte interface, make selections using the interface elements shown below. """) with gradio.Row(): hours_per_week = gradio.Slider(0, 80, step=0.5, value=5.0, label=FEATURE_COLS[0]) num_songs = gradio.Number(value=200, precision=0, label=FEATURE_COLS[1]) num_playlists = gradio.Number(value=5, precision=0, label=FEATURE_COLS[2]) with gradio.Row(): share_label = gradio.Radio(choices=LIKERT5_LABELS, value="Sometimes", label="How often do you share music with others?") live_events_label = gradio.Radio(choices=LIKERT5_LABELS, value="Rarely", label="How often do you attend live music events?") with gradio.Row(): decade_label = gradio.Radio(choices=DECADE_LABELS, value="2010s", label="Which decade of music do you listen to most?") lyrics_label = gradio.Radio(choices=LYRICS_LABELS, value="Lyrics", label="Do you prefer songs with lyrics or instrumental music?") proba_pretty = gradio.Label(num_top_classes=5, label="Class probabilities") inputs = [hours_per_week, num_songs, num_playlists, share_label, decade_label, live_events_label, lyrics_label] for comp in inputs: comp.change(fn=do_predict, inputs=inputs, outputs=[proba_pretty]) gradio.Examples( examples=EXAMPLES, inputs=inputs, label="Representative examples", examples_per_page=5, cache_examples=False, ) if __name__ == "__main__": demo.launch()