2025.03.18.post1

Fixes, Memory handling updates, storage fixes.

dashboard.py

@@ -1,10 +1,55 @@
 import streamlit as st
+from transformers.utils.hub import TRANSFORMERS_CACHE
+import shutil
+import torch
+import psutil
+import gc
+import os
+
+def free_memory():
+    #  """Free up CPU & GPU memory before loading a new model."""
+    global current_model, current_tokenizer
+
+    if current_model is not None:
+        del current_model  # Delete the existing model
+        current_model = None  # Reset reference
+
+    if current_tokenizer is not None:
+        del current_tokenizer  # Delete the tokenizer
+        current_tokenizer = None
+
+    gc.collect()  # Force garbage collection for CPU memory
+
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()  # Free GPU memory
+        torch.cuda.ipc_collect()  # Clean up PyTorch GPU cache
+
+    # If running on CPU, reclaim memory using OS-level commands
+    try:
+        if torch.cuda.is_available() is False:
+            psutil.virtual_memory()  # Refresh memory stats
+    except Exception as e:
+        print(f"Memory cleanup error: {e}")
+
+    # Delete cached Hugging Face models
+    try:
+        cache_dir = TRANSFORMERS_CACHE
+        if os.path.exists(cache_dir):
+            shutil.rmtree(cache_dir)
+            print("Cache cleared!")
+    except Exception as e:
+        print(f"❌ Cache cleanup error: {e}")
 
 def show_dashboard():
+    # free_memory()
     st.title("Tachygraphy Micro-text Analysis & Normalization")
     st.write("""
         Welcome to the Tachygraphy Micro-text Analysis & Normalization Project. This application is designed to analyze text data through three stages:
         1. Sentiment Polarity Analysis
         2. Emotion Mood-tag Analysis
         3. Text Transformation & Normalization
-    """)
+    """)
+
+
+def __main__():
+    show_dashboard()

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tachygraphy-microtext-analysis-and-normalization"
-version = "2025.03.17.post1"
+version = "2025.03.18.post1"
 description = ""
 authors = [
     { name = "Archisman Karmakar", email = "[email protected]" },

pyprojectOLD.toml

@@ -1,6 +1,9 @@
 [project]
 name = "tachygraphy-microtext-analysis-and-normalization"
-version = "2025.03.16.post3"
+version = "2025.03.17.post1"
+# version = "2025.03.16.post3"
+# version = "2025.03.16.post2"
+# version = "2025.03.16.post1"
 description = ""
 authors = [
     { name = "Archisman Karmakar", email = "[email protected]" },

sentiment_analysis/config/stage1_models.json

@@ -12,5 +12,19 @@
         "device": "cpu",
         "load_function": "load_model",
         "predict_function": "predict"
+    },
+    "2": {
+        "name": "DeBERTa v3 Base Custom Model with minimal Regularized Loss",
+        "type": "db3_base_custom",
+        "module_path": "hmv_cfg_base_stage1.model2",
+        "hf_location": "tachygraphy-microtrext-norm-org/DeBERTa-v3-Base-Cust-LV1-SentimentPolarities-minRegLoss",
+        "tokenizer_class": "DebertaV2Tokenizer",
+        "model_class": "SentimentModel",
+        "problem_type": "multi_label_classification",
+        "base_model": "microsoft/deberta-v3-base",
+        "num_labels": 3,
+        "device": "cpu",
+        "load_function": "load_model",
+        "predict_function": "predict"
     }
 }

sentiment_analysis/hmv_cfg_base_stage1/imports.py

@@ -1,5 +1,5 @@
 import streamlit as st
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModel, DebertaV2Tokenizer, DebertaV2ForSequenceClassification
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoModel, DebertaV2Tokenizer, DebertaV2ForSequenceClassification, DebertaV2Model
 import torch
 import numpy as np
 import matplotlib.pyplot as plt
@@ -13,4 +13,10 @@ import importlib
 import importlib.util
 import asyncio
 import sys
-import pytorch_lightning as pl
+import pytorch_lightning as pl
+
+import safetensors
+from safetensors import load_file, save_file
+import json
+import huggingface_hub
+from huggingface_hub import hf_hub_download

sentiment_analysis/hmv_cfg_base_stage1/model1.py

@@ -34,10 +34,12 @@ def load_model():
     tokenizer_class = globals()[model_info["tokenizer_class"]]
     model_class = globals()[model_info["model_class"]]
     tokenizer = tokenizer_class.from_pretrained(hf_location)
+    print("Loading model 1")
     model = model_class.from_pretrained(hf_location,
                                         problem_type=model_info["problem_type"],
                                         num_labels=model_info["num_labels"]
                                         )
+    print("Model 1 loaded")
 
     return model, tokenizer
 
@@ -58,12 +60,14 @@ def predict(text, model, tokenizer, device, max_len=128):
 
     # probabilities = outputs.logits.cpu().numpy()
 
-    probabilities = torch.relu(outputs.logits)
-    probabilities = torch.clamp(torch.tensor(probabilities), min=0.00000, max=1.00000).cpu().numpy()
+    # probabilities = torch.relu(outputs.logits)
+    # probabilities = torch.clamp(torch.tensor(probabilities), min=0.00000, max=1.00000).cpu().numpy()
     # probabilities /= probabilities.sum()
     # probabilities = probabilities.cpu().numpy()
 
-    return probabilities
+    predictions = torch.sigmoid(outputs.logits).cpu().numpy()
+
+    return predictions
 
 
 if __name__ == "__main__":

sentiment_analysis/hmv_cfg_base_stage1/model2.py

@@ -0,0 +1,250 @@
+from imports import *
+
+import importlib.util
+import os
+import sys
+import joblib
+
+import torch
+import torch.nn as nn
+import torch.functional as F
+from transformers import DebertaV2Model, DebertaV2Tokenizer
+import safetensors
+# from safetensors import load_file, save_file
+import json
+from huggingface_hub import hf_hub_download
+from safetensors.torch import save_file, safe_open
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), )))
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+CONFIG_STAGE1 = os.path.join(BASE_DIR, "..", "config", "stage1_models.json")
+
+MODEL_OPTIONS = {
+"2": {
+        "name": "DeBERTa v3 Base Custom Model with minimal Regularized Loss",
+        "type": "db3_base_custom",
+        "module_path": "hmv_cfg_base_stage1.model2",
+        "hf_location": "tachygraphy-microtrext-norm-org/DeBERTa-v3-Base-Cust-LV1-SentimentPolarities-minRegLoss",
+        "tokenizer_class": "DebertaV2Tokenizer",
+        "model_class": "SentimentModel",
+        "problem_type": "multi_label_classification",
+        "base_model": "microsoft/deberta-v3-base",
+        "num_labels": 3,
+        "device": "cpu",
+        "load_function": "load_model",
+        "predict_function": "predict"
+    }
+}
+
+
+# class SentimentModel(nn.Module):
+#     def __init__(self, roberta_model=DebertaV2Model.from_pretrained(
+#             'microsoft/deberta-v3-base',
+#             device_map=torch.device("cuda" if torch.cuda.is_available() else "cpu")
+#         ), n_classes=3, dropout_rate=0.2):
+#         super(SentimentModel, self).__init__()
+
+#         self.roberta = roberta_model
+#         self.drop = nn.Dropout(p=dropout_rate)
+#         self.fc1 = nn.Linear(self.roberta.config.hidden_size, 256)  # Reduced neurons
+#         self.relu = nn.ReLU()
+#         self.out = nn.Linear(256, n_classes)
+
+#     def forward(self, input_ids, attention_mask):
+#         output = self.roberta(input_ids=input_ids, attention_mask=attention_mask)
+#         cls_token_state = output.last_hidden_state[:, 0, :]
+#         output = self.drop(cls_token_state)
+#         output = self.relu(self.fc1(output))
+#         return self.out(output)
+
+#     def save_pretrained(self, save_directory):
+#         os.makedirs(save_directory, exist_ok=True)
+
+#         # Save model weights using safetensors
+#         model_weights = self.state_dict()
+#         save_file(model_weights, os.path.join(save_directory, "model.safetensors"))
+
+#         # Save model config
+#         config = {
+#             "hidden_size": self.roberta.config.hidden_size,
+#             "num_labels": self.out.out_features,
+#             "dropout_rate": self.drop.p,
+#             "roberta_model": self.roberta.name_or_path
+#         }
+#         with open(os.path.join(save_directory, "config.json"), "w") as f:
+#             json.dump(config, f)
+
+#         print(f"Model saved in {save_directory}")
+
+#     @classmethod
+#     def load_pretrained(cls, model_path_or_repo, roberta_model):
+#         # if model_path_or_repo.startswith("http") or "/" not in model_path_or_repo:
+#         #     # Load from Hugging Face Hub
+#         #     model_config_path = hf_hub_download(model_path_or_repo, "config.json")
+#         #     model_weights_path = hf_hub_download(model_path_or_repo, "model.safetensors")
+#         # else:
+#         #     # Load from local directory
+#         #     model_config_path = os.path.join(model_path_or_repo, "config.json")
+#         #     model_weights_path = os.path.join(model_path_or_repo, "model.safetensors")
+
+#         model_config_path = hf_hub_download(model_path_or_repo, "config.json")
+#         model_weights_path = hf_hub_download(model_path_or_repo, "model.safetensors")
+
+#         # Load model config
+#         with open(model_config_path, "r") as f:
+#             config = json.load(f)
+
+#         # Load RoBERTa model
+#         roberta_model = DebertaV2Model.from_pretrained(config["roberta_model"])
+
+#         # Initialize SentimentModel
+#         model = cls(
+#             roberta_model,
+#             n_classes=config["num_labels"],
+#             dropout_rate=config["dropout_rate"]
+#         )
+
+#         # Load safetensors weights
+#         with safe_open(model_weights_path, framework="pt", device="cpu") as f:
+#             model_weights = {key: f.get_tensor(key) for key in f.keys()}
+#         model.load_state_dict(model_weights)
+
+#         print(f"Model loaded from {model_path_or_repo}")
+#         return model
+
+
+class SentimentModel(nn.Module):
+    def __init__(self, roberta_model, n_classes=3, dropout_rate=0.2):
+        super(SentimentModel, self).__init__()
+
+        self.roberta = roberta_model
+        self.drop = nn.Dropout(p=dropout_rate)
+        self.fc1 = nn.Linear(self.roberta.config.hidden_size, 256)
+        self.relu = nn.ReLU()
+        self.out = nn.Linear(256, n_classes)
+
+    def forward(self, input_ids, attention_mask):
+        output = self.roberta(input_ids=input_ids, attention_mask=attention_mask)
+        cls_token_state = output.last_hidden_state[:, 0, :]
+        output = self.drop(cls_token_state)
+        output = self.relu(self.fc1(output))
+        return self.out(output)
+
+    def save_pretrained(self, save_directory):
+        os.makedirs(save_directory, exist_ok=True)
+
+        model_weights = self.state_dict()
+        save_file(model_weights, os.path.join(save_directory, "model.safetensors"))
+
+        config = {
+            "hidden_size": self.roberta.config.hidden_size,
+            "num_labels": self.out.out_features,
+            "dropout_rate": self.drop.p,
+            "roberta_model": self.roberta.name_or_path,  # ✅ Save model name
+        }
+        with open(os.path.join(save_directory, "config.json"), "w") as f:
+            json.dump(config, f)
+
+        print(f"Model saved in {save_directory}")
+
+
+    @classmethod
+    @st.cache_resource
+    def load_pretrained(cls, model_path_or_repo):
+        """Loads and caches the model (RoBERTa + SentimentModel) only when called."""
+        print(f"Loading model from {model_path_or_repo}...")
+
+        model_config_path = hf_hub_download(model_path_or_repo, "config.json")
+        model_weights_path = hf_hub_download(model_path_or_repo, "model.safetensors")
+
+        with open(model_config_path, "r") as f:
+            config = json.load(f)
+
+        print(f"Loading RoBERTa model: {config['roberta_model']}...")
+        roberta_model = DebertaV2Model.from_pretrained(
+            config["roberta_model"],
+        )
+
+        model = cls(
+            roberta_model, n_classes=config["num_labels"], dropout_rate=config["dropout_rate"]
+        )
+
+        with safe_open(model_weights_path, framework="pt", device="cpu") as f:
+            model_weights = {key: f.get_tensor(key) for key in f.keys()}
+        model.load_state_dict(model_weights)
+
+        print(f"Model loaded from {model_path_or_repo}")
+        return model
+
+
+@st.cache_resource
+
+# def load_pretrained(model_path_or_repo):
+
+#     model_config_path = hf_hub_download(model_path_or_repo, "config.json")
+#     model_weights_path = hf_hub_download(model_path_or_repo, "model.safetensors")
+
+#     with open(model_config_path, "r") as f:
+#         config = json.load(f)
+
+#     roberta_model = DebertaV2Model.from_pretrained(
+#         config["roberta_model"],
+#     )
+
+#     model = SentimentModel(
+#         roberta_model, n_classes=config["num_labels"], dropout_rate=config["dropout_rate"]
+#     )
+
+#     with safe_open(model_weights_path, framework="pt", device="cpu") as f:
+#         model_weights = {key: f.get_tensor(key) for key in f.keys()}
+#     model.load_state_dict(model_weights)
+
+#     print(f"Model loaded from {model_path_or_repo}")
+#     return model
+
+    
+
+def load_model():
+    model_key = "2"
+    model_info = MODEL_OPTIONS[model_key]
+    hf_location = model_info["hf_location"]
+
+    tokenizer_class = globals()[model_info["tokenizer_class"]]
+    model_class = globals()[model_info["model_class"]]
+    tokenizer = tokenizer_class.from_pretrained(hf_location)
+    print("Loading model 2")
+    model = SentimentModel.load_pretrained(hf_location)
+    print("Model 2 loaded")
+    # model.eval()
+
+    return model, tokenizer
+
+
+def predict(text, model, tokenizer, device, max_len=128):
+    # model.eval()  # Set model to evaluation mode
+
+    # Tokenize and pad the input text
+    inputs = tokenizer(
+        text,
+        None,
+        add_special_tokens=True,
+        padding=True,
+        truncation=False,
+        return_tensors="pt",
+        return_token_type_ids=False,
+    ).to(device)  # Move input tensors to the correct device
+
+    with torch.no_grad():
+        outputs = model(**inputs)
+
+    # Apply sigmoid activation (for BCEWithLogitsLoss)
+    probabilities = torch.sigmoid(outputs).cpu().numpy()
+    # probabilities = outputs.cpu().numpy()
+
+    return probabilities
+
+
+if __name__ == "__main__":
+    model, tokenizer = load_model("2")
+    print("Model and tokenizer loaded successfully.")

sentiment_analysis/hmv_cfg_base_stage1/{stage1_bert_architecture.py → model3.py}

@@ -1,26 +1,66 @@
-import torch.nn as nn    
-
-class BERT_architecture(nn.Module):
-
-    def __init__(self, bert):
-        super(BERT_architecture, self).__init__()
-        self.bert = bert
-        
-        self.dropout = nn.Dropout(0.3)  # Increased dropout for regularization
-        self.layer_norm = nn.LayerNorm(768)  # Layer normalization
-        
-        self.fc1 = nn.Linear(768, 256)  # Dense layer
-        self.fc2 = nn.Linear(256, 3)  # Output layer with 3 classes
-        
-        self.relu = nn.ReLU()
-        self.softmax = nn.LogSoftmax(dim=1)
-
-    def forward(self, sent_id, mask, token_type_ids):
-        _, cls_hs = self.bert(sent_id, attention_mask=mask, token_type_ids=token_type_ids, return_dict=False)
-        x = self.layer_norm(cls_hs)
-        x = self.fc1(x)
-        x = self.relu(x)
-        x = self.dropout(x)
-        x = self.fc2(x)
-        x = self.softmax(x)
-        return x
+from imports import *
+
+import importlib.util
+import os
+import sys
+import joblib
+
+import torch
+import torch.nn as nn
+import torch.functional as F
+from transformers import DebertaV2Model, DebertaV2Tokenizer
+import safetensors
+# from safetensors import load_file, save_file
+import json
+from huggingface_hub import hf_hub_download
+from safetensors.torch import save_file, safe_open
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), )))
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+CONFIG_STAGE1 = os.path.join(BASE_DIR, "..", "config", "stage1_models.json")
+
+MODEL_OPTIONS = {
+    "3": {
+        "name": "BERT Base Uncased Custom Model",
+        "type": "db3_base_custom",
+        "module_path": "hmv_cfg_base_stage1.model2",
+        "hf_location": "tachygraphy-microtrext-norm-org/DeBERTa-v3-Base-Cust-LV1-SentimentPolarities-minRegLoss",
+        "tokenizer_class": "DebertaV2Tokenizer",
+        "model_class": "BERT_architecture",
+        "problem_type": "multi_label_classification",
+        "base_model": "google/bert-base-uncased",
+        "num_labels": 3,
+        "device": "cpu",
+        "load_function": "load_model",
+        "predict_function": "predict"
+    }
+}
+
+
+class BERT_architecture(nn.Module):
+
+    def __init__(self, bert=AutoModel.from_pretrained("bert-base-uncased",
+                                                      device_map=torch.device("cuda" if torch.cuda.is_available() else "cpu"))):
+        super(BERT_architecture, self).__init__()
+        self.bert = bert
+
+        self.dropout = nn.Dropout(0.3)  # Increased dropout for regularization
+        self.layer_norm = nn.LayerNorm(768)  # Layer normalization
+
+        self.fc1 = nn.Linear(768, 256)  # Dense layer
+        self.fc2 = nn.Linear(256, 3)  # Output layer with 3 classes
+
+        self.relu = nn.ReLU()
+        self.softmax = nn.LogSoftmax(dim=1)
+
+    def forward(self, sent_id, mask, token_type_ids):
+        _, cls_hs = self.bert(sent_id, attention_mask=mask,
+                              token_type_ids=token_type_ids, return_dict=False)
+        x = self.layer_norm(cls_hs)
+        x = self.fc1(x)
+        x = self.relu(x)
+        x = self.dropout(x)
+        x = self.fc2(x)
+        x = self.softmax(x)
+        return x

sentiment_analysis/sentiment_analysis_main.py

@@ -3,6 +3,11 @@ import importlib.util
 import os
 import sys
 import joblib
+import time
+# from transformers.utils import move_cache_to_trash 
+# from huggingface_hub import delete_cache
+from transformers.utils.hub import TRANSFORMERS_CACHE
+import shutil
 
 sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), )))
 
@@ -13,10 +18,6 @@ BASE_DIR = os.path.dirname(os.path.abspath(__file__))
 CONFIG_STAGE1 = os.path.join(BASE_DIR, "config", "stage1_models.json")
 LOADERS_STAGE1 = os.path.join(BASE_DIR, "hmv-cfg-base-stage1")
 
-# Load the model and tokenizer
-# model_name = "tachygraphy-microtrext-norm-org/DeBERTa-v3-seqClassfication-LV1-SentimentPolarities-Batch8"
-# tokenizer = AutoTokenizer.from_pretrained(model_name)
-# model = AutoModel.from_pretrained(model_name)
 
 SENTIMENT_POLARITY_LABELS = [
     "negative", "neutral", "positive"
@@ -26,23 +27,19 @@ current_model = None
 current_tokenizer = None
 
 # Enabling Resource caching
-@st.cache_resource
 
+
+@st.cache_resource
 def load_model_config():
     with open(CONFIG_STAGE1, "r") as f:
         model_data = json.load(f)
 
-    model_options = {v["name"]: v for v in model_data.values()}  # Extract names for dropdown
+    # Extract names for dropdown
+    model_options = {v["name"]: v for v in model_data.values()}
     return model_data, model_options
 
-MODEL_DATA, MODEL_OPTIONS = load_model_config()
-
 
-
-# def load_model():
-#     model = DebertaV2ForSequenceClassification.from_pretrained(model_name)
-#     tokenizer = DebertaV2Tokenizer.from_pretrained(model_name)
-#     return model, tokenizer
+MODEL_DATA, MODEL_OPTIONS = load_model_config()
 
 
 # ✅ Dynamically Import Model Functions
@@ -69,7 +66,7 @@ def free_memory():
 
     gc.collect()  # Force garbage collection for CPU memory
 
-    if torch.cuda.is_available():  
+    if torch.cuda.is_available():
         torch.cuda.empty_cache()  # Free GPU memory
         torch.cuda.ipc_collect()  # Clean up PyTorch GPU cache
 
@@ -80,10 +77,22 @@ def free_memory():
     except Exception as e:
         print(f"Memory cleanup error: {e}")
 
+    # Delete cached Hugging Face models
+    try:
+        cache_dir = TRANSFORMERS_CACHE
+        if os.path.exists(cache_dir):
+            shutil.rmtree(cache_dir)
+            print("Cache cleared!")
+    except Exception as e:
+        print(f"❌ Cache cleanup error: {e}")
+
+
 
 def load_selected_model(model_name):
     global current_model, current_tokenizer
 
+    st.cache_resource.clear()
+
     free_memory()
 
     # st.write("DEBUG: Available Models:", MODEL_OPTIONS.keys())  # ✅ See available models
@@ -109,10 +118,163 @@ def load_selected_model(model_name):
         return None, None, None
 
     model, tokenizer = load_model_func()
-    
+
     current_model, current_tokenizer = model, tokenizer
     return model, tokenizer, predict_func
 
+
+# Function to increment progress dynamically
+def update_progress(progress_bar, start, end, delay=0.1):
+    for i in range(start, end + 1, 5):  # Increment in steps of 5%
+        progress_bar.progress(i)
+        time.sleep(delay)  # Simulate processing time
+        # st.experimental_rerun() # Refresh the page
+
+
+# Function to update session state when model changes
+def on_model_change():
+    st.session_state.model_changed = True  # Mark model as changed
+    
+
+# Function to update session state when text changes
+
+
+def on_text_change():
+    st.session_state.text_changed = True  # Mark text as changed
+
+
+# Initialize session state variables
+if "selected_model" not in st.session_state:
+    st.session_state.selected_model = list(MODEL_OPTIONS.keys())[
+        0]  # Default model
+if "user_input" not in st.session_state:
+    st.session_state.user_input = ""
+if "last_processed_input" not in st.session_state:
+    st.session_state.last_processed_input = ""
+if "model_changed" not in st.session_state:
+    st.session_state.model_changed = False
+if "text_changed" not in st.session_state:
+    st.session_state.text_changed = False
+if "processing" not in st.session_state:
+    st.session_state.processing = False
+
+
+def show_sentiment_analysis():
+    st.cache_resource.clear()
+    free_memory()
+
+    st.title("Stage 1: Sentiment Polarity Analysis")
+    st.write("This section handles sentiment analysis.")
+
+    # Model selection with change detection
+    selected_model = st.selectbox(
+        "Choose a model:", list(MODEL_OPTIONS.keys()), key="selected_model", on_change=on_model_change
+    )
+
+    # Text input with change detection
+    user_input = st.text_input(
+        "Enter text for sentiment analysis:", key="user_input", on_change=on_text_change
+    )
+    user_input_copy = user_input
+
+    # Only run inference if:
+    # 1. The text is NOT empty
+    # 2. The text has changed OR the model has changed
+    if user_input.strip() and (st.session_state.text_changed or st.session_state.model_changed):
+
+        # Reset session state flags
+        st.session_state.last_processed_input = user_input
+        st.session_state.model_changed = False
+        st.session_state.text_changed = False   # Store selected model
+
+        # ADD A DYNAMIC PROGRESS BAR
+        progress_bar = st.progress(0)
+        update_progress(progress_bar, 0, 10)
+        # status_text = st.empty()
+
+        # update_progress(0, 10)
+        # status_text.text("Loading model...")
+
+        # Make prediction
+
+        # model, tokenizer = load_model()
+        # model, tokenizer = load_selected_model(selected_model)
+        with st.spinner("Please wait..."):
+            model, tokenizer, predict_func = load_selected_model(selected_model)
+            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+            if model is None:
+                st.error(
+                    "⚠️ Error: Model failed to load! Check model selection or configuration.")
+                st.stop()
+
+            model.to(device)
+
+            # predictions = predict(user_input, model, tokenizer, device)
+
+            predictions = predict_func(user_input, model, tokenizer, device)
+
+            # Squeeze predictions to remove extra dimensions
+            predictions_array = predictions.squeeze()
+
+            # Convert to binary predictions (argmax)
+            binary_predictions = np.zeros_like(predictions_array)
+            max_indices = np.argmax(predictions_array)
+            binary_predictions[max_indices] = 1
+
+            # Update progress bar for prediction and model loading
+            update_progress(progress_bar, 10, 100)
+
+        # Display raw predictions
+        st.write(f"**Predicted Sentiment Scores:** {predictions_array}")
+
+        # Display binary classification result
+        st.write(f"**Predicted Sentiment:**")
+        st.write(
+            f"**NEGATIVE:** {binary_predictions[0]}, **NEUTRAL:** {binary_predictions[1]}, **POSITIVE:** {binary_predictions[2]}")
+        # st.write(f"**NEUTRAL:** {binary_predictions[1]}")
+        # st.write(f"**POSITIVE:** {binary_predictions[2]}")
+
+        # 1️⃣ **Polar Plot (Plotly)**
+        sentiment_polarities = predictions_array.tolist()
+        fig_polar = px.line_polar(
+            pd.DataFrame(dict(r=sentiment_polarities,
+                         theta=SENTIMENT_POLARITY_LABELS)),
+            r='r', theta='theta', line_close=True
+        )
+        st.plotly_chart(fig_polar)
+
+        # 2️⃣ **Normalized Horizontal Bar Chart (Matplotlib)**
+        normalized_predictions = predictions_array / predictions_array.sum()
+
+        fig, ax = plt.subplots(figsize=(8, 2))
+        left = 0
+        for i in range(len(normalized_predictions)):
+            ax.barh(0, normalized_predictions[i], color=plt.cm.tab10(
+                i), left=left, label=SENTIMENT_POLARITY_LABELS[i])
+            left += normalized_predictions[i]
+
+        # Configure the chart
+        ax.set_xlim(0, 1)
+        ax.set_yticks([])
+        ax.set_xticks(np.arange(0, 1.1, 0.1))
+        ax.legend(loc='upper center', bbox_to_anchor=(
+            0.5, -0.15), ncol=len(SENTIMENT_POLARITY_LABELS))
+        plt.title("Sentiment Polarity Prediction Distribution")
+
+        # Display in Streamlit
+        st.pyplot(fig)
+
+        progress_bar.empty()
+
+
+if __name__ == "__main__":
+    show_sentiment_analysis()
+
+
+### COMMENTED OUT CODE ###
+
+
 # def load_selected_model(model_name):
 #     # """Load model and tokenizer based on user selection."""
 #     global current_model, current_tokenizer
@@ -157,7 +319,7 @@ def load_selected_model(model_name):
 #     # else:
 #     #     st.error("Invalid model selection")
 #     #     return None, None
-    
+
 
 #     if load_model_func is None or predict_func is None:
 #         st.error("❌ Model functions could not be loaded!")
@@ -167,30 +329,29 @@ def load_selected_model(model_name):
 #     # return model, tokenizer
 
 #     model, tokenizer = load_model_func(hf_location)
-    
+
 #     current_model, current_tokenizer = model, tokenizer
 #     return model, tokenizer, predict_func
 
 
+# def predict(text, model, tokenizer, device, max_len=128):
+#     # Tokenize and pad the input text
+#     inputs = tokenizer(
+#         text,
+#         add_special_tokens=True,
+#         padding=True,
+#         truncation=False,
+#         return_tensors="pt",
+#         return_token_type_ids=False,
+#     ).to(device)  # Move input tensors to the correct device
 
-def predict(text, model, tokenizer, device, max_len=128):
-    # Tokenize and pad the input text
-    inputs = tokenizer(
-        text,
-        add_special_tokens=True,
-        padding=True,
-        truncation=False,
-        return_tensors="pt",
-        return_token_type_ids=False,
-    ).to(device)  # Move input tensors to the correct device
+#     with torch.no_grad():
+#         outputs = model(**inputs)
 
-    with torch.no_grad():
-        outputs = model(**inputs)
+#     # Apply sigmoid activation (for BCEWithLogitsLoss)
+#     probabilities = outputs.logits.cpu().numpy()
 
-    # Apply sigmoid activation (for BCEWithLogitsLoss)
-    probabilities = outputs.logits.cpu().numpy()
-
-    return probabilities 
+#     return probabilities
 
 # def show_sentiment_analysis():
 
@@ -200,97 +361,119 @@ def predict(text, model, tokenizer, device, max_len=128):
     # user_input = st.text_area("Enter text for sentiment analysis:", height=200)
     # user_input = st.text_area("Enter text for sentiment analysis:", max_chars=500)
 
-def show_sentiment_analysis():
-    st.title("Stage 1: Sentiment Polarity Analysis")
-    st.write("This section will handle sentiment analysis.")
+# def show_sentiment_analysis():
+#     st.title("Stage 1: Sentiment Polarity Analysis")
+#     st.write("This section will handle sentiment analysis.")
 
-    if "selected_model" not in st.session_state:
-        st.session_state.selected_model = list(MODEL_OPTIONS.keys())[0]  # Default selection
+#     if "selected_model" not in st.session_state:
+#         st.session_state.selected_model = list(MODEL_OPTIONS.keys())[0]  # Default selection
 
-    if "clear_output" not in st.session_state:
-        st.session_state.clear_output = False
+#     if "clear_output" not in st.session_state:
+#         st.session_state.clear_output = False
 
-    st.selectbox("Choose a model:", list(MODEL_OPTIONS.keys()), key="selected_model")
+#     st.selectbox("Choose a model:", list(MODEL_OPTIONS.keys()), key="selected_model")
 
-    selected_model = st.session_state.selected_model
+#     selected_model = st.session_state.selected_model
 
-    if selected_model not in MODEL_OPTIONS:
-        st.error(f"❌ Selected model '{selected_model}' not found!")
-        st.stop()
+#     if selected_model not in MODEL_OPTIONS:
+#         st.error(f"❌ Selected model '{selected_model}' not found!")
+#         st.stop()
 
-    st.session_state.clear_output = True  # Reset output when model changes
+#     st.session_state.clear_output = True  # Reset output when model changes
 
 
-    # st.write("DEBUG: Available Models:", MODEL_OPTIONS.keys())  # ✅ See available models
-    # st.write("DEBUG: Selected Model:", MODEL_OPTIONS[selected_model])  # ✅ Check selected model
+#     # st.write("DEBUG: Available Models:", MODEL_OPTIONS.keys())  # ✅ See available models
+#     # st.write("DEBUG: Selected Model:", MODEL_OPTIONS[selected_model])  # ✅ Check selected model
 
 
-    user_input = st.text_input("Enter text for sentiment analysis:")
+#     user_input = st.text_input("Enter text for sentiment analysis:")
+#     user_input_copy = user_input
 
-    if user_input:
-        # Make prediction
+#     # if st.button("Run Analysis"):
+#     #     if not user_input.strip():
+#     #         st.warning("⚠️ Please enter some text before running analysis.")
+#     #         return
 
-        # model, tokenizer = load_model()
-        # model, tokenizer = load_selected_model(selected_model)
+#     # with st.form(key="sentiment_form"):
+#     #     user_input = st.text_input("Enter text for sentiment analysis:")
+#     #     submit_button = st.form_submit_button("Run Analysis")
 
-        model, tokenizer, predict_func = load_selected_model(selected_model)
-        device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+#     #     user_input_copy = user_input
 
-        if model is None:
-            st.error("⚠️ Error: Model failed to load! Check model selection or configuration.")
-            st.stop()
+#     if user_input.strip():
 
-        model.to(device)
+#         ADD A DYNAMIC PROGRESS BAR
+#         progress_bar = st.progress(0)
+#         update_progress(progress_bar, 0, 10)
+#         # status_text = st.empty()
 
-        # predictions = predict(user_input, model, tokenizer, device)
+#         # update_progress(0, 10)
+#         # status_text.text("Loading model...")
 
-        predictions = predict_func(user_input, model, tokenizer, device)
+#         # Make prediction
 
-        # Squeeze predictions to remove extra dimensions
-        predictions_array = predictions.squeeze()
+#         # model, tokenizer = load_model()
+#         # model, tokenizer = load_selected_model(selected_model)
 
-        # Convert to binary predictions (argmax)
-        binary_predictions = np.zeros_like(predictions_array)
-        max_indices = np.argmax(predictions_array)
-        binary_predictions[max_indices] = 1
+#         model, tokenizer, predict_func = load_selected_model(selected_model)
+#         device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-        # Display raw predictions
-        st.write(f"**Predicted Sentiment Scores:** {predictions_array}")
+#         if model is None:
+#             st.error("⚠️ Error: Model failed to load! Check model selection or configuration.")
+#             st.stop()
 
-        # Display binary classification result
-        st.write(f"**Predicted Sentiment:**")
-        st.write(f"**NEGATIVE:** {binary_predictions[0]}, **NEUTRAL:** {binary_predictions[1]}, **POSITIVE:** {binary_predictions[2]}")
-        # st.write(f"**NEUTRAL:** {binary_predictions[1]}")
-        # st.write(f"**POSITIVE:** {binary_predictions[2]}")
+#         model.to(device)
 
-        # 1️⃣ **Polar Plot (Plotly)**
-        sentiment_polarities = predictions_array.tolist()
-        fig_polar = px.line_polar(
-            pd.DataFrame(dict(r=sentiment_polarities, theta=SENTIMENT_POLARITY_LABELS)), 
-            r='r', theta='theta', line_close=True
-        )
-        st.plotly_chart(fig_polar)
+#         # predictions = predict(user_input, model, tokenizer, device)
 
-        # 2️⃣ **Normalized Horizontal Bar Chart (Matplotlib)**
-        normalized_predictions = predictions_array / predictions_array.sum()
+#         predictions = predict_func(user_input, model, tokenizer, device)
 
-        fig, ax = plt.subplots(figsize=(8, 2))
-        left = 0
-        for i in range(len(normalized_predictions)):
-            ax.barh(0, normalized_predictions[i], color=plt.cm.tab10(i), left=left, label=SENTIMENT_POLARITY_LABELS[i])
-            left += normalized_predictions[i]
+#         # Squeeze predictions to remove extra dimensions
+#         predictions_array = predictions.squeeze()
 
-        # Configure the chart
-        ax.set_xlim(0, 1)
-        ax.set_yticks([])
-        ax.set_xticks(np.arange(0, 1.1, 0.1))
-        ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=len(SENTIMENT_POLARITY_LABELS))
-        plt.title("Sentiment Polarity Prediction Distribution")
+#         # Convert to binary predictions (argmax)
+#         binary_predictions = np.zeros_like(predictions_array)
+#         max_indices = np.argmax(predictions_array)
+#         binary_predictions[max_indices] = 1
 
-        # Display in Streamlit
-        st.pyplot(fig)
-        
 
+#         # Update progress bar for prediction and model loading
+#         update_progress(progress_bar, 10, 100)
 
-if __name__ == "__main__":
-    show_sentiment_analysis()
+#         # Display raw predictions
+#         st.write(f"**Predicted Sentiment Scores:** {predictions_array}")
+
+#         # Display binary classification result
+#         st.write(f"**Predicted Sentiment:**")
+#         st.write(f"**NEGATIVE:** {binary_predictions[0]}, **NEUTRAL:** {binary_predictions[1]}, **POSITIVE:** {binary_predictions[2]}")
+#         # st.write(f"**NEUTRAL:** {binary_predictions[1]}")
+#         # st.write(f"**POSITIVE:** {binary_predictions[2]}")
+
+#         # 1️⃣ **Polar Plot (Plotly)**
+#         sentiment_polarities = predictions_array.tolist()
+#         fig_polar = px.line_polar(
+#             pd.DataFrame(dict(r=sentiment_polarities, theta=SENTIMENT_POLARITY_LABELS)),
+#             r='r', theta='theta', line_close=True
+#         )
+#         st.plotly_chart(fig_polar)
+
+#         # 2️⃣ **Normalized Horizontal Bar Chart (Matplotlib)**
+#         normalized_predictions = predictions_array / predictions_array.sum()
+
+#         fig, ax = plt.subplots(figsize=(8, 2))
+#         left = 0
+#         for i in range(len(normalized_predictions)):
+#             ax.barh(0, normalized_predictions[i], color=plt.cm.tab10(i), left=left, label=SENTIMENT_POLARITY_LABELS[i])
+#             left += normalized_predictions[i]
+
+#         # Configure the chart
+#         ax.set_xlim(0, 1)
+#         ax.set_yticks([])
+#         ax.set_xticks(np.arange(0, 1.1, 0.1))
+#         ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.15), ncol=len(SENTIMENT_POLARITY_LABELS))
+#         plt.title("Sentiment Polarity Prediction Distribution")
+
+#         # Display in Streamlit
+#         st.pyplot(fig)
+
+#         progress_bar.empty()