Upload 6 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+IMDB[[:space:]]Dataset.csv filter=lfs diff=lfs merge=lfs -text

IMDB Dataset.csv

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

a.py

@@ -0,0 +1,131 @@
+import streamlit as st
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics import accuracy_score, classification_report
+from sklearn.naive_bayes import MultinomialNB
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.svm import SVC
+import pickle
+import matplotlib.pyplot as plt
+
+st.title(":blue[IMDB Dataset of 50k reviews]")
+
+
+@st.cache_data
+def load_data():
+    return pd.read_csv('IMDB Dataset.csv')
+if 'models' not in st.session_state:
+    st.session_state.models = {}
+if 'vectorizer' not in st.session_state:
+    st.session_state.vectorizer = None
+if 'accuracy' not in st.session_state:
+    st.session_state.accuracy = {}
+if 'report' not in st.session_state:
+    st.session_state.report = {}
+
+# Dataset
+st.header("Dataset")
+df = load_data()
+with st.expander("Show Data"):
+    st.write(df)
+df['sentiment'] = df['sentiment'].map({'positive':1,'negative':0})
+X = df['review']
+y = df['sentiment']
+X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=41)
+
+tfidf_vectorizer = TfidfVectorizer()  
+X_train_tfidf = tfidf_vectorizer.fit_transform(X_train)  
+X_test_tfidf = tfidf_vectorizer.transform(X_test)  
+
+
+if not st.session_state.models:  
+    st.session_state.vectorizer = TfidfVectorizer()  
+    X_train_tfidf = st.session_state.vectorizer.fit_transform(X_train)  
+
+    # models  
+    models = {  
+        # "SVM": SVC(kernel='linear'),  
+        "Logistic Regression": LogisticRegression(max_iter=1000),
+        "Naive Bayes": MultinomialNB()  
+    }  
+
+    for name, model in models.items():  
+        model.fit(X_train_tfidf, y_train)  
+        st.session_state.models[name] = model  
+        X_test_tfidf = st.session_state.vectorizer.transform(X_test)  
+        y_pred = model.predict(X_test_tfidf)  
+        st.session_state.accuracy[name] = accuracy_score(y_test, y_pred)  
+        st.session_state.report[name] = classification_report(y_test, y_pred)  
+
+if st.session_state.accuracy:  
+    
+    plt.figure(figsize=(10, 5))  
+    plt.bar(st.session_state.accuracy.keys(), st.session_state.accuracy.values(), color=['blue', 'orange', 'green'])  
+    plt.ylabel('Accuracy')  
+    plt.title('Model Accuracy Comparison')  
+    st.pyplot(plt)  
+
+    for name in st.session_state.report:  
+        st.write(f"### Classification Report for {name}:")  
+        # st.text(st.session_state.report[name])  
+        st.dataframe(st.session_state.report[name])
+
+st.header("Manual Tryouts",divider='orange')
+# Input text from the user  
+user_input = st.text_area("Enter your Review", "")  
+
+if st.button("Predict"):  
+    if user_input:  
+        # Vectorize user input for all models  
+        user_input_tfidf = st.session_state.vectorizer.transform([user_input])  
+
+        # Predict using all models  
+        predictions = {}  
+        for name, model in st.session_state.models.items():  
+            prediction = model.predict(user_input_tfidf)  
+            predictions[name] = "Positive" if prediction[0] == 1 else "Negative"  
+        
+        # Display predictions for each model  
+        st.write("Predicted Sentiment:")  
+        for name in predictions:  
+            st.write(f"{name}: **{predictions[name]}**")  
+    else:  
+        st.write("Please enter a review.")
+# # Linear Regression
+# st.header('Linear Regression',divider='orange')
+# model = LogisticRegression()  
+# model.fit(X_train_tfidf, y_train)  
+
+# y_pred = model.predict(X_test_tfidf)  
+
+# print("Accuracy:", accuracy_score(y_test, y_pred))  
+# print(classification_report(y_test, y_pred))
+
+# filename = 'linear_regression_model.pkl'
+# with open(filename, 'wb') as model_file:
+#     pickle.dump(model, model_file)
+
+# st.write("Accuracy:", accuracy_score(y_test, y_pred))  
+# st.markdown(body=classification_report(y_test, y_pred),unsafe_allow_html=True)  
+
+# # Naive Bayes
+# st.header("Naive Bayes",divider='orange')
+# model_nb = MultinomialNB()  
+# model_nb.fit(X_train_tfidf, y_train)  
+
+# # Evaluate the model  
+# y_pred = model_nb.predict(X_test_tfidf)  
+# st.write("Accuracy:", accuracy_score(y_test, y_pred))  
+# st.markdown(body=classification_report(y_test, y_pred),unsafe_allow_html=True)  
+
+# # SVM
+# st.header("Support Vector Machine")
+# st.caption("Kernal type is linear.")
+# model = SVC(kernel='linear')  # You can also try 'rbf', 'poly', etc.  
+# model.fit(X_train_tfidf, y_train)  
+
+# y_pred = model.predict(X_test_tfidf)  
+# st.write("Accuracy:", accuracy_score(y_test, y_pred))  
+# st.markdown(body=classification_report(y_test, y_pred),unsafe_allow_html=True)  

linear_regression.py

@@ -0,0 +1,33 @@
+import pandas as pd  
+from sklearn.model_selection import train_test_split  
+from sklearn.feature_extraction.text import TfidfVectorizer  
+from sklearn.linear_model import LogisticRegression  
+from sklearn.metrics import accuracy_score, classification_report  
+import pickle
+
+df = pd.read_csv('IMDB Dataset.csv')  
+
+print(df.head())  
+
+df['sentiment'] = df['sentiment'].map({'positive': 1, 'negative': 0})  
+print(df.isnull())
+
+X = df['review']  
+y = df['sentiment']  
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)  
+
+tfidf_vectorizer = TfidfVectorizer()  
+X_train_tfidf = tfidf_vectorizer.fit_transform(X_train)  
+X_test_tfidf = tfidf_vectorizer.transform(X_test)
+
+model = LogisticRegression()  
+model.fit(X_train_tfidf, y_train)  
+
+y_pred = model.predict(X_test_tfidf)  
+
+print("Accuracy:", accuracy_score(y_test, y_pred))  
+print(classification_report(y_test, y_pred))
+
+filename = 'linear_regression_model.pkl'
+with open(filename, 'wb') as model_file:
+    pickle.dump(model, model_file)

linear_regression_model.pkl

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

main.py

@@ -0,0 +1,118 @@
+import streamlit as st  
+import pandas as pd  
+import numpy as np  
+import matplotlib.pyplot as plt  
+from sklearn.feature_extraction.text import TfidfVectorizer  
+from sklearn.model_selection import train_test_split  
+from sklearn.svm import SVC  
+from sklearn.linear_model import LogisticRegression  
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier  
+from sklearn.metrics import accuracy_score, classification_report  
+from transformers import BertTokenizer, BertForSequenceClassification  
+import torch  
+
+@st.cache_data  
+def load_data():  
+    return pd.read_csv('IMDB Dataset.csv')  
+
+if 'models' not in st.session_state:  
+    st.session_state.models = {}  
+if 'reports' not in st.session_state:  
+    st.session_state.reports = {}  
+if 'accuracy' not in st.session_state:  
+    st.session_state.accuracy = {}  
+
+df = load_data()  
+
+df['sentiment'] = df['sentiment'].map({'positive': 1, 'negative': 0})  
+
+X = df['review']  
+y = df['sentiment']  
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)  
+
+if not st.session_state.models:  
+    vectorizer = TfidfVectorizer()  
+    X_train_tfidf = vectorizer.fit_transform(X_train)  
+
+    # models
+    models = {  
+        "SVM": SVC(kernel='linear'),  
+        "Logistic Regression": LogisticRegression(max_iter=1000),  
+        "Random Forest": RandomForestClassifier(n_estimators=10),  
+        "Gradient Boosting": GradientBoostingClassifier()  
+    }  
+
+    for name, model in models.items():  
+        model.fit(X_train_tfidf, y_train)  
+        st.session_state.models[name] = model  
+        X_test_tfidf = vectorizer.transform(X_test)  
+        y_pred = model.predict(X_test_tfidf)  
+        st.session_state.accuracy[name] = accuracy_score(y_test, y_pred)  
+        report = classification_report(y_test, y_pred, output_dict=True)  
+        st.session_state.reports[name] = pd.DataFrame(report).transpose()  
+
+    st.session_state.bert_tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')  
+    st.session_state.bert_model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2)  
+
+    train_encodings = st.session_state.bert_tokenizer(list(X_train), truncation=True, padding=True, return_tensors='pt')  
+    train_labels = torch.tensor(y_train.values)  
+
+    train_dataset = torch.utils.data.TensorDataset(train_encodings['input_ids'], train_encodings['attention_mask'], train_labels)  
+
+    training_args = torch.optim.AdamW(st.session_state.bert_model.parameters(), lr=1e-5)  
+    st.session_state.bert_model.train()  
+
+    for epoch in range(1):  
+        for batch in train_dataset:  
+            inputs = batch[0], batch[1]  
+            labels = batch[2]  
+            outputs = st.session_state.bert_model(*inputs, labels=labels)  
+            loss = outputs.loss  
+            loss.backward()  
+            training_args.step()  
+            training_args.zero_grad()  
+
+    st.session_state.bert_model.eval()  
+    test_encodings = st.session_state.bert_tokenizer(list(X_test), truncation=True, padding=True, return_tensors='pt')  
+    with torch.no_grad():  
+        outputs = st.session_state.bert_model(test_encodings['input_ids'], test_encodings['attention_mask'])  
+    predictions = torch.argmax(outputs.logits, dim=1).numpy()  
+    st.session_state.accuracy["BERT"] = accuracy_score(y_test, predictions)  
+    report = classification_report(y_test, predictions, output_dict=True)  
+    st.session_state.reports["BERT"] = pd.DataFrame(report).transpose()  
+
+if st.session_state.accuracy:  
+    
+    plt.figure(figsize=(10, 5))  
+    plt.bar(st.session_state.accuracy.keys(), st.session_state.accuracy.values(), color=['blue', 'orange', 'green','red', 'purple'])  
+    plt.ylabel('Accuracy')  
+    plt.title('Model Accuracy Comparison')  
+    st.pyplot(plt)  
+
+    for name, report_df in st.session_state.reports.items():  
+        st.header(f"{name}",divider='orange')  
+        st.dataframe(report_df)  
+
+st.header("Manual Tryouts")
+user_input = st.text_area("Review", "")  
+
+if st.button("Predict"):  
+    if user_input:  
+        user_input_tfidf = vectorizer.transform([user_input])  
+
+        predictions = {}  
+        for name, model in st.session_state.models.items():  
+            prediction = model.predict(user_input_tfidf)  
+            predictions[name] = "Positive" if prediction[0] == 1 else "Negative"  
+
+        inputs = st.session_state.bert_tokenizer(user_input, return_tensors='pt', truncation=True, padding=True)  
+        with torch.no_grad():  
+            output = st.session_state.bert_model(inputs['input_ids'], inputs['attention_mask'])  
+        bert_prediction = torch.argmax(output.logits, dim=1).item()  
+        predictions["BERT"] = "Positive" if bert_prediction == 1 else "Negative"  
+
+        st.write("Predicted Sentiment:")  
+        for name in predictions:  
+            st.write(f"{name}: **{predictions[name]}**")  
+    else:  
+        st.write("Please enter a review.")

requirements.txt

@@ -0,0 +1,6 @@
+matplotlib
+pandas
+scikit_learn
+streamlit
+torch
+transformers