Spaces:
Paused
Paused
Download app.py from Surajnitp/Trackmodel: direct link, hf CLI and curl.
- Browser
- Download file 9 kB
-
https://huggingface.co/spaces/Surajnitp/Trackmodel/resolve/main/app.py
- Command line
-
hf download hf://spaces/Surajnitp/Trackmodel/app.py
-
curl -L -o app.py https://huggingface.co/spaces/Surajnitp/Trackmodel/resolve/main/app.py
9 kB
| """ | |
| Trackmodel - Gradio Web App | |
| This app loads your fine-tuned model and provides a web interface | |
| """ | |
| import os | |
| import shutil | |
| import subprocess | |
| import sys | |
| import gradio as gr | |
| from transformers import pipeline | |
| classifier = None | |
| HUB_MODEL = "Surajnitp/sentiment-trackmodel" | |
| LOCAL_MODEL_DIR = os.path.abspath("./my_finetuned_model") | |
| DATA_MODEL_DIR = "/data/my_finetuned_model" | |
| def persistent_model_dir(): | |
| if os.path.isdir("/data"): | |
| return DATA_MODEL_DIR | |
| return LOCAL_MODEL_DIR | |
| def model_dir_is_valid(path): | |
| if not path or not os.path.isdir(path): | |
| return False | |
| has_config = os.path.isfile(os.path.join(path, "config.json")) | |
| has_weights = any( | |
| os.path.isfile(os.path.join(path, name)) | |
| for name in ("model.safetensors", "pytorch_model.bin", "model.safetensors.index.json") | |
| ) | |
| return has_config and has_weights | |
| def find_local_model_dir(): | |
| for path in (DATA_MODEL_DIR, LOCAL_MODEL_DIR, "./my_finetuned_model"): | |
| if model_dir_is_valid(path): | |
| return os.path.abspath(path) | |
| return None | |
| def format_status(text): | |
| return f"""<div class="status-box"> | |
| **Status:** {text} | |
| </div>""" | |
| def load_model(): | |
| """Load Hub model first, then local weights, then the default SST-2 model.""" | |
| global classifier | |
| print(f"[load_model] cwd={os.getcwd()}", flush=True) | |
| print(f"[load_model] HF_TOKEN set={bool(os.getenv('HF_TOKEN'))}", flush=True) | |
| try: | |
| print(f"[load_model] trying Hub: {HUB_MODEL}", flush=True) | |
| classifier = pipeline( | |
| "sentiment-analysis", | |
| model=HUB_MODEL, | |
| tokenizer=HUB_MODEL, | |
| ) | |
| status = f"โ Loaded model from Hub: {HUB_MODEL}" | |
| print(f"[load_model] {status}", flush=True) | |
| return status | |
| except Exception as hub_err: | |
| print(f"[load_model] Hub load failed: {hub_err}", flush=True) | |
| model_path = find_local_model_dir() | |
| if model_path: | |
| try: | |
| print(f"[load_model] trying local: {model_path}", flush=True) | |
| classifier = pipeline( | |
| "sentiment-analysis", | |
| model=model_path, | |
| tokenizer=model_path, | |
| ) | |
| status = f"โ Loaded fine-tuned model from local ({model_path})" | |
| print(f"[load_model] {status}", flush=True) | |
| return status | |
| except Exception as local_err: | |
| print(f"[load_model] local load failed: {local_err}", flush=True) | |
| try: | |
| classifier = pipeline( | |
| "sentiment-analysis", | |
| model="distilbert-base-uncased-finetuned-sst-2-english", | |
| ) | |
| status = ( | |
| "โ ๏ธ Using default model. Hub and local fine-tuned weights were not found. " | |
| f"Set HF_TOKEN, train once to push {HUB_MODEL}, then restart." | |
| ) | |
| print(f"[load_model] {status}", flush=True) | |
| return status | |
| except Exception as e2: | |
| status = f"โ CRITICAL: Could not load any model: {str(e2)}" | |
| print(f"[load_model] {status}", flush=True) | |
| return status | |
| def predict(text): | |
| """Predict sentiment of input text""" | |
| if not text or not text.strip(): | |
| return "โ ๏ธ Please enter some text to analyze." | |
| if classifier is None: | |
| return "โ Model not loaded. Please restart the app." | |
| try: | |
| result = classifier(text) | |
| label = result[0]["label"] | |
| score = result[0]["score"] | |
| emoji = "๐" if label.upper() in ("POSITIVE", "POS", "LABEL_1") else "๐" | |
| return f""" | |
| ### ๐ Sentiment Analysis Result | |
| {emoji} **Label:** {label} | |
| ๐ฏ **Confidence:** {score:.2%} | |
| --- | |
| ๐ **Text analyzed:** "{text[:100]}{'...' if len(text) > 100 else ''}" | |
| """ | |
| except Exception as e: | |
| return f"โ Error during prediction: {str(e)}" | |
| def persist_trained_model(): | |
| """Copy weights to /data when persistent storage is available.""" | |
| src = find_local_model_dir() or LOCAL_MODEL_DIR | |
| dest = persistent_model_dir() | |
| if not model_dir_is_valid(src): | |
| return src, dest, False | |
| if os.path.abspath(src) != os.path.abspath(dest): | |
| os.makedirs(os.path.dirname(dest) or ".", exist_ok=True) | |
| if os.path.isdir(dest): | |
| shutil.rmtree(dest) | |
| shutil.copytree(src, dest) | |
| print(f"[persist] copied {src} -> {dest}", flush=True) | |
| return src, dest, True | |
| def run_training(): | |
| """Run the training script and return training log + live status.""" | |
| try: | |
| if not os.path.exists("train.py"): | |
| status = "โ Training script not found!" | |
| return status, format_status(status) | |
| env = os.environ.copy() | |
| env["PYTHONUNBUFFERED"] = "1" | |
| env["MODEL_SAVE_DIR"] = persistent_model_dir() | |
| result = subprocess.run( | |
| [sys.executable, "-u", "train.py"], | |
| capture_output=True, | |
| text=True, | |
| timeout=1200, | |
| env=env, | |
| ) | |
| full_output = (result.stdout or "") + (result.stderr or "") | |
| if len(full_output) > 4000: | |
| full_output = full_output[:4000] + "\n... (output truncated)" | |
| persist_trained_model() | |
| model_path = find_local_model_dir() | |
| if result.returncode == 0 and model_path: | |
| load_status = load_model() | |
| message = f"""โ Training completed successfully! | |
| Full Output: | |
| {full_output} | |
| Model saved to: {model_path} | |
| Status: {load_status} | |
| If HF_TOKEN is set, the model was also pushed to {HUB_MODEL}. | |
| Restart the Space to load permanently from the Hub.""" | |
| return message, format_status(load_status) | |
| fail_status = load_model() | |
| message = f"""โ Training failed. (Exit code: {result.returncode}) | |
| Model folder present: {bool(model_path)} | |
| Output: | |
| {full_output}""" | |
| return message, format_status(fail_status) | |
| except subprocess.TimeoutExpired: | |
| status = "โฐ Training timed out after 20 minutes." | |
| return status, format_status(load_model()) | |
| except Exception as e: | |
| status = f"โ Unexpected error during training: {str(e)}" | |
| return status, format_status(status) | |
| startup_status = load_model() | |
| with gr.Blocks( | |
| title="Trackmodel - Sentiment Analysis", | |
| theme=gr.themes.Soft(), | |
| css=".gradio-container {max-width: 800px; margin: auto;} .status-box {padding: 10px; border-radius: 5px; background: #f0f0f0;}", | |
| ) as demo: | |
| gr.Markdown(""" | |
| # ๐ฏ Trackmodel - Sentiment Analysis | |
| This Space demonstrates downloading, fine-tuning, and deploying models on Hugging Face. | |
| **Model:** DistilBERT fine-tuned on IMDb reviews for sentiment classification. | |
| """) | |
| status_box = gr.Markdown(format_status(startup_status)) | |
| with gr.Tab("๐ฌ Predict"): | |
| gr.Markdown("### Enter text to analyze sentiment") | |
| with gr.Row(): | |
| with gr.Column(scale=4): | |
| text_input = gr.Textbox( | |
| label="Your text", | |
| placeholder="Type something like: 'I love this movie!'", | |
| lines=4, | |
| ) | |
| with gr.Column(scale=1): | |
| predict_btn = gr.Button("๐ฎ Predict", variant="primary", size="lg") | |
| clear_btn = gr.Button("๐๏ธ Clear", variant="secondary") | |
| output = gr.Markdown( | |
| value="๐ Enter text and click 'Predict' to see results.", | |
| ) | |
| with gr.Tab("โ๏ธ Training"): | |
| gr.Markdown(""" | |
| ### Train the Model on Custom Data | |
| Click the button below to fine-tune the model on the IMDb dataset. | |
| โ ๏ธ **Note:** This will take ~3-5 minutes on a CPU instance. | |
| Add Space secret `HF_TOKEN` first. Training then uploads to `Surajnitp/sentiment-trackmodel` so the model survives restarts. | |
| """) | |
| with gr.Row(): | |
| train_btn = gr.Button("๐ Start Training", variant="primary", size="lg") | |
| train_output = gr.Markdown("โน๏ธ Click the button to start training.") | |
| with gr.Tab("โน๏ธ About"): | |
| gr.Markdown(""" | |
| ## About Trackmodel | |
| ### What this Space does: | |
| 1. **Downloads** a pre-trained DistilBERT model | |
| 2. **Fine-tunes** it on the IMDb movie review dataset | |
| 3. **Deploys** the trained model as a web app | |
| ### How to use: | |
| - Go to the **Predict** tab to analyze text sentiment | |
| - Go to the **Training** tab to fine-tune the model yourself | |
| ### Links: | |
| - [Hugging Face Models](https://huggingface.co/models) | |
| - [Gradio Documentation](https://gradio.app/docs) | |
| - [Hugging Face Course](https://huggingface.co/learn/nlp-course) | |
| ### Author: | |
| **Surajnitp** ๐ | |
| """) | |
| predict_btn.click(fn=predict, inputs=text_input, outputs=output) | |
| clear_btn.click(fn=lambda: "", inputs=None, outputs=text_input) | |
| clear_btn.click( | |
| fn=lambda: "๐ Enter text and click 'Predict' to see results.", | |
| inputs=None, | |
| outputs=output, | |
| ) | |
| train_btn.click(fn=run_training, inputs=None, outputs=[train_output, status_box]) | |
| demo.load(fn=lambda: format_status(load_model()), outputs=status_box) | |
| if __name__ == "__main__": | |
| demo.launch() | |