Upload 11 files

abcd.py

@@ -0,0 +1,49 @@
+import streamlit as st
+import torch
+from transformers import RobertaForSequenceClassification, RobertaTokenizer
+import pandas as pd
+
+def model1():
+    # Your Model 1 code here
+    st.subheader("Emotion Analysis")
+    model_path = "mode.pth"  # Replace with the actual path to your trained model
+    tokenizer = RobertaTokenizer.from_pretrained(model_path)
+    model = RobertaForSequenceClassification.from_pretrained(model_path)
+
+    # Set the model to evaluation mode
+    model.eval()
+
+    # Labels for your specific task
+    labels = ["anger", "fear", "joy"]  # Replace with your actual label names
+
+    # Streamlit app
+    user_input = st.text_area("Enter text for analysis:")
+    if st.button("Analyze"):
+        if user_input:
+            # Tokenize and preprocess the input
+            input_ids = tokenizer.encode(user_input, return_tensors="pt")
+            # Make prediction
+            with torch.no_grad():
+                output = model(input_ids)
+            # Get predicted probabilities
+            probabilities = torch.sigmoid(output.logits)
+
+            # Check if the lengths match before creating the DataFrame
+            if len(labels) == len(probabilities[0]):
+                # Display the probabilities as individual bars
+                df = pd.DataFrame({
+                    "Label": labels,
+                    "Probability": probabilities[0].tolist()
+                })
+
+                st.bar_chart(df.set_index("Label"))
+
+                # Display the emotion labels and scores
+                st.subheader("Emotion Analysis Output:")
+                for i, result in enumerate(sorted(zip(labels, probabilities[0]), key=lambda x: x[1], reverse=True)):
+                    label, score = result
+                    st.write(f"{i + 1}. {label.capitalize()}: {score:.4f}")
+            else:
+                st.error("Error: The length of labels and probabilities does not match.")
+        else:
+            st.warning("Please enter text for analysis.")

app.py

@@ -0,0 +1,48 @@
+import streamlit as st
+import random
+
+def celsius_to_fahrenheit(celsius):
+    return (celsius * 9/5) + 32
+
+def main():
+    st.title("Smart Home Control")git
+
+    # General on/off button
+    general_status = st.button("General On")
+    general_status_off = st.button("General Off")
+
+    # Temperature control
+    st.header("Temperature Control")
+    temperature_status = st.button("Temperature On")
+    temperature_status_off = st.button("Temperature Off")
+
+    temperature_unit = st.radio("Select Temperature Unit", ["Celsius", "Fahrenheit"])
+    min_temp = 28 if temperature_unit == "Celsius" else celsius_to_fahrenheit(28)
+    max_temp = 40 if temperature_unit == "Celsius" else celsius_to_fahrenheit(40)
+
+    temperature_value = st.number_input(f"Set Temperature ({temperature_unit})", min_value=float(min_temp), max_value=float(max_temp), step=1.0)
+
+    # Camera control
+    st.header("Camera Control")
+    camera_status = st.button("Camera On")
+    camera_status_off = st.button("Camera Off")
+
+    # Light control
+    st.header("Light Control")
+    light_status = st.button("Light On")
+    light_status_off = st.button("Light Off")
+
+    # Display weight randomly
+    st.header("Weight Display")
+    weight_value = random.uniform(100, 300)
+    st.write(f"Weight: {weight_value:.2f} pounds")
+
+    # Show status based on button clicks
+    st.write("\n**Status:**")
+    st.write(f"- General: {'On' if general_status else 'Off'}")
+    st.write(f"- Temperature: {'On' if temperature_status else 'Off'}")
+    st.write(f"- Camera: {'On' if camera_status else 'Off'}")
+    st.write(f"- Light: {'On' if light_status else 'Off'}")
+
+if __name__ == "__main__":
+    main()

count_vectorizer.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28846f62e43097bf18bd2a51ff2dc544bc7cad7814a3c0a7aaa8ec1c2521328a
+size 101316

emotion_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38e8be9c8fdcbbdcfe5507ecc82102f12d7dce91f837737d514652ef409b7e87
+size 380047

main.py

@@ -0,0 +1,25 @@
+import streamlit as st
+from model1 import model1
+from model2 import model2
+from model3 import model3
+
+
+def main():
+    st.title("Text Classification App")
+
+    # Model selection
+    model_selection = st.selectbox("Select Model", ["Model 1", "Model 2", "Model 3"])
+
+    if model_selection == "Model 1":
+        model3()
+    elif model_selection == "Model 2":
+        model1()
+    elif model_selection == "Model 3":
+        model2()
+
+
+
+
+
+if __name__ == "__main__":
+    main()

model1.py

@@ -0,0 +1,49 @@
+import streamlit as st
+import torch
+from transformers import RobertaForSequenceClassification, RobertaTokenizer
+import pandas as pd
+
+def model1():
+    # Your Model 1 code here
+    st.subheader("Model 2 Analysis")
+    model_path = "mymodel.pth"  # Replace with the actual path to your trained model
+    tokenizer = RobertaTokenizer.from_pretrained(model_path)
+    model = RobertaForSequenceClassification.from_pretrained(model_path)
+
+    # Set the model to evaluation mode
+    model.eval()
+
+    # Labels for your specific task
+    labels = ["anger", "fear", "joy"]  # Replace with your actual label names
+
+    # Streamlit app
+    user_input = st.text_area("Enter text for analysis:")
+    if st.button("Analyze"):
+        if user_input:
+            # Tokenize and preprocess the input
+            input_ids = tokenizer.encode(user_input, return_tensors="pt")
+            # Make prediction
+            with torch.no_grad():
+                output = model(input_ids)
+            # Get predicted probabilities
+            probabilities = torch.sigmoid(output.logits)
+
+            # Check if the lengths match before creating the DataFrame
+            if len(labels) == len(probabilities[0]):
+                # Display the probabilities as individual bars
+                df = pd.DataFrame({
+                    "Label": labels,
+                    "Probability": probabilities[0].tolist()
+                })
+
+                st.bar_chart(df.set_index("Label"))
+
+                # Display the emotion labels and scores
+                st.subheader("Emotion Analysis Output:")
+                for i, result in enumerate(sorted(zip(labels, probabilities[0]), key=lambda x: x[1], reverse=True)):
+                    label, score = result
+                    st.write(f"{i + 1}. {label.capitalize()}: {score:.4f}")
+            else:
+                st.error("Error: The length of labels and probabilities does not match.")
+        else:
+            st.warning("Please enter text for analysis.")

model2.py

@@ -0,0 +1,46 @@
+import streamlit as st
+import joblib
+from sklearn.feature_extraction.text import TfidfVectorizer
+
+
+def model2():
+    # Load the saved model
+    model_filename = "emotion_model.joblib"
+    loaded_model = joblib.load(model_filename)
+
+    # Load the TfidfVectorizer (assuming you used TfidfVectorizer during training)
+    vectorizer_filename = "count_vectorizer.joblib"  # Update this to the correct filename
+    vectorizer = joblib.load(vectorizer_filename)
+
+    # Streamlit App
+    st.title("Emotion Prediction App")
+
+    # Input text from the user
+    user_input = st.text_area("Enter your text:")
+
+    # Analyze button
+    if st.button("Analyze"):
+        # Make predictions with new data
+        if user_input:
+            new_data = [user_input]
+            new_features = vectorizer.transform(new_data)
+            new_predictions = loaded_model.predict_proba(new_features)
+
+            # Display predictions using a progress bar
+            st.subheader("Emotion Scores:")
+
+            # Assuming there are three classes (Fear, Anger, Joy)
+            progress_bar_fear = st.progress(new_predictions[0][0])
+            st.write("Fear:", round(new_predictions[0][0], 2))
+            progress_bar_anger = st.progress(new_predictions[0][1])
+            st.write("Anger:", round(new_predictions[0][1], 2))
+            progress_bar_joy = st.progress(new_predictions[0][2])
+            st.write("Joy:", round(new_predictions[0][2], 2))
+
+
+
+
+
+# Call the function to run the app
+if __name__ == "__main__":
+    model2()

model3.py

@@ -0,0 +1,45 @@
+import streamlit as st
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.feature_extraction.text import CountVectorizer
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.pipeline import make_pipeline
+from sklearn.metrics import accuracy_score, classification_report
+
+
+def model3():
+    # Load the CSV file
+    df = pd.read_csv('Emotion_classify_Data.csv')
+
+    # Assuming your CSV has two columns: 'text' and 'label'
+    X = df['Comment']
+    y = df['Emotion']
+
+    # Split the dataset into training and testing sets
+    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+    # Create a text classification pipeline using a bag-of-words model and a Naive Bayes classifier
+    model = make_pipeline(CountVectorizer(), MultinomialNB())
+
+    # Train the model
+    model.fit(X_train, y_train)
+
+    # Function to make predictions
+    def predict_emotion(text):
+        prediction = model.predict([text])
+        return prediction[0]
+
+    # Streamlit app
+    st.title("Emotion Classification App")
+
+    # User input for prediction
+    user_input = st.text_area("Enter a sentence:")
+
+    if st.button("Predict"):
+        if user_input:
+            # Make prediction
+            prediction = predict_emotion(user_input)
+            st.success(f"Predicted Emotion: {prediction}")
+        else:
+            st.warning("Please enter a sentence for prediction.")
+