├── CNAME ├── CONTRIBUTING.md ├── link.txt ├── .github ├── FUNDING.yml ├── ISSUE_TEMPLATE │ └── custom.md └── workflows │ └── python-package-conda.yml ├── Model ├── model.pkl └── vectorizer.pkl ├── environment.yml ├── README.md ├── LICENSE ├── twitterapiaccount.py └── twitterapiaccount.ipynb /CNAME: -------------------------------------------------------------------------------- 1 | dtweet.me -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | 2 | -------------------------------------------------------------------------------- /link.txt: -------------------------------------------------------------------------------- 1 | https://colab.research.google.com/drive/1q7pmP3GtNueW7iA4mVutlMdT7BcFZKJR?usp=sharing 2 | -------------------------------------------------------------------------------- /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | # These are supported funding model platforms 2 | 3 | github: SUBHADIPMAITI-DEV 4 | 5 | 6 | -------------------------------------------------------------------------------- /Model/model.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SUBHADIPMAITI-DEV/Depression-Detection-System-Using-Machine-Learning/HEAD/Model/model.pkl -------------------------------------------------------------------------------- /Model/vectorizer.pkl: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/SUBHADIPMAITI-DEV/Depression-Detection-System-Using-Machine-Learning/HEAD/Model/vectorizer.pkl -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/custom.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Custom issue template 3 | about: Describe this issue template's purpose here. 4 | title: '' 5 | labels: '' 6 | assignees: '' 7 | 8 | --- 9 | 10 | 11 | -------------------------------------------------------------------------------- /environment.yml: -------------------------------------------------------------------------------- 1 | name: my-environment 2 | channels: 3 | - defaults 4 | dependencies: 5 | - python=3.10 6 | - pandas 7 | - numpy 8 | - scikit-learn 9 | - matplotlib 10 | - pip 11 | - pip: 12 | - some-pip-package 13 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | # Depression-Detection-System-Using-Machine-Learning 7 | 8 | 9 | 10 | SYSTEM REQUIREMENT 11 | 12 | 🔎Hardware Requirements: 13 | System Processing: I3 10TH Gen ; 14 | RAM: 8GB ; 15 | Storage: SSD 512 GB ; 16 | Also, we can use cloud execution for GPU – Google Colab architecture. 17 | 18 | 🔎Software Requirements: 19 | OS: Windows 10 ; 20 | Google Colab ; 21 | 22 | 23 | RESULT ANALYSIS 24 | ![image](https://user-images.githubusercontent.com/78700974/204124779-9d353689-2adb-499d-97e3-171c69f4ee8f.png) 25 | 26 | RESULT VIDEO 27 | 28 | 29 | https://github.com/SUBHADIPMAITI-DEV/Depression-Detection-System-Using-Machine-Learning/assets/78700974/f70aed97-32f2-4086-a80c-51770771f1c4 30 | 31 | 32 | 33 | 34 | 35 | 36 | DOWNLOAD THE PROJECT REPORT ➡️ 37 | 38 | 39 | 40 | 41 | 42 | 📁[Depression.Detection.System.Using.Machine.Learning.Report.SM.G1.pdf](https://github.com/user-attachments/files/16267929/Depression.Detection.System.Using.Machine.Learning.Report.SM.G1_removed.pdf) 43 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2023 Subhadip Maiti 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /.github/workflows/python-package-conda.yml: -------------------------------------------------------------------------------- 1 | name: Python Package using Conda 2 | 3 | on: [push] 4 | 5 | jobs: 6 | build-linux: 7 | runs-on: ubuntu-latest 8 | strategy: 9 | max-parallel: 5 10 | 11 | steps: 12 | - uses: actions/checkout@v3 13 | - name: Set up Python 3.10 14 | uses: actions/setup-python@v3 15 | with: 16 | python-version: '3.10' 17 | - name: Add conda to system path 18 | run: | 19 | # $CONDA is an environment variable pointing to the root of the miniconda directory 20 | echo $CONDA/bin >> $GITHUB_PATH 21 | - name: Install dependencies 22 | run: | 23 | conda env update --file environment.yml --name base 24 | - name: Lint with flake8 25 | run: | 26 | conda install flake8 27 | # stop the build if there are Python syntax errors or undefined names 28 | flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics 29 | # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide 30 | flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics 31 | - name: Test with pytest 32 | run: | 33 | conda install pytest 34 | pytest 35 | -------------------------------------------------------------------------------- /twitterapiaccount.py: -------------------------------------------------------------------------------- 1 | # -*- coding: utf-8 -*- 2 | """twitterapiaccount.ipynb 3 | 4 | Automatically generated by Colaboratory. 5 | 6 | Original file is located at 7 | https://colab.research.google.com/drive/1q7pmP3GtNueW7iA4mVutlMdT7BcFZKJR 8 | """ 9 | 10 | from google.colab import drive 11 | drive.mount('/content/drive') 12 | 13 | !pip install better_profanity 14 | import nltk 15 | 16 | nltk.download('punkt') 17 | nltk.download('stopwords') 18 | nltk.download('wordnet') 19 | nltk.download('omw-1.4') 20 | 21 | 22 | 23 | RAW_INPUT_TRAINING_DATA = "/content/drive/MyDrive/twitterapiaccount/dataset_combined_2510_new.csv" 24 | 25 | 26 | 27 | USER_TWEET_DATA_FILE = "user_tweets.csv" 28 | PREPROCESSED_INPUT_TRAINING_DATA = "preprocessed_input_data.csv" 29 | MODEL_FILE = "model.pkl" 30 | VECTORIZER_FILE = "vectorizer.pkl" 31 | 32 | # Commented out IPython magic to ensure Python compatibility. 33 | 34 | #DATA CLEANING: Vectorizer AND NLP 35 | 36 | import pandas as pd 37 | import numpy as np 38 | import matplotlib.pyplot as plt 39 | # %matplotlib inline 40 | 41 | import re 42 | from sklearn.feature_extraction.text import TfidfVectorizer 43 | 44 | #importing nlp packages 45 | from nltk import stem 46 | from nltk.corpus import stopwords 47 | stemmer = stem.SnowballStemmer('english') 48 | stopwords = set(stopwords.words('english')) 49 | 50 | 51 | #removing the special characters and numbers and url 52 | def keep_alpha(s): 53 | # s = row['content'] 54 | non_url = re.sub(r"http\S+", "", s) 55 | res = re.sub('[^a-zA-Z\s]', '', non_url) 56 | res1 = re.sub('\n', '', res) 57 | return res1 58 | 59 | def nlp_preprocessing(msg): 60 | try: 61 | # converting messages to lowercase 62 | msg = msg.lower() 63 | # removing stopwords 64 | msg = [word for word in msg.split() if word not in stopwords] 65 | # using a stemmer (getting root form of each word of each row) 66 | msg = " ".join([stemmer.stem(word) for word in msg]) 67 | 68 | except Exception as e: 69 | print(e) 70 | 71 | return msg 72 | 73 | 74 | df=pd.read_csv(RAW_INPUT_TRAINING_DATA) 75 | df.rename(columns = {'Text':'tweet'}, inplace = True) 76 | df = df.dropna() 77 | df = df.sample(frac=1).reset_index() 78 | #df = df.sample(frac=0.1).reset_index() 79 | 80 | 81 | # data preprocessing using NLP : nltk 82 | df['tweet'] = df['tweet'].astype(str) 83 | #remove leading and ending whitespaces 84 | df['tweet'] = df['tweet'].str.strip() 85 | 86 | # keep only alphabets 87 | df['tweet'] = df['tweet'].apply(keep_alpha) 88 | 89 | # nlp preprocessing to remove stopwords and get base/stem form of each word 90 | df['tweet'] = df['tweet'].apply(nlp_preprocessing) 91 | print(df.head(2)) 92 | print(df.tail(2)) 93 | 94 | 95 | print(df['depressed'].value_counts()) 96 | 97 | # df.to_csv("data//preprocessed_input_data.csv", index=False) 98 | df.to_csv(PREPROCESSED_INPUT_TRAINING_DATA, index=False) 99 | 100 | import pandas as pd 101 | from sklearn import metrics 102 | from sklearn.metrics import confusion_matrix 103 | from sklearn.metrics import accuracy_score 104 | from sklearn.metrics import plot_confusion_matrix 105 | 106 | 107 | # to save or to load model 108 | import joblib 109 | 110 | svmout=0 111 | lrout=0 112 | dtout=0 113 | 114 | ## SVM 115 | def train_svm(X_train, X_test, y_train, y_test): 116 | 117 | from sklearn import svm 118 | svm = svm.SVC(C=1000) 119 | 120 | # training svm model 121 | svm.fit(X_train, y_train) 122 | 123 | print("\n\n----SVM------") 124 | y_pred = svm.predict(X_test) 125 | print("Confusion matrix SVM:\n", confusion_matrix(y_test, y_pred)) 126 | 127 | plot_confusion_matrix(svm, X_test, y_test) 128 | plt.show() 129 | 130 | svmout=round((accuracy_score(y_test, y_pred) * 100),2) 131 | # calculate the accuracy 132 | print("Accuracy score for SVM: ", round((accuracy_score(y_test, y_pred) * 100),2)) 133 | 134 | return svm, svmout 135 | 136 | 137 | 138 | ## Logistic regression 139 | def train_logistic_regression(X_train, X_test, y_train, y_test): 140 | from sklearn.linear_model import LogisticRegression 141 | # Create an instance of the model. 142 | logreg = LogisticRegression() 143 | # Training the model. 144 | logreg.fit(X_train,y_train) 145 | 146 | #Do prediction. 147 | y_pred=logreg.predict(X_test) 148 | 149 | print("\n\n-----------Logistic Regression-----") 150 | print("Confusion matrix Logistic Regression:\n",confusion_matrix(y_test, y_pred)) 151 | 152 | plot_confusion_matrix(logreg, X_test, y_test) 153 | plt.show() 154 | 155 | lrout=round((accuracy_score(y_test, y_pred) * 100),2) 156 | # calculate the accuracy 157 | print("Accuracy score for Logistic regression: ", round((accuracy_score(y_test, y_pred) * 100),2)) 158 | return logreg, lrout 159 | 160 | 161 | 162 | ## Decision Tree 163 | def train_decision_tree(X_train, X_test, y_train, y_test): 164 | from sklearn.tree import DecisionTreeClassifier 165 | model = DecisionTreeClassifier() 166 | model.fit(X_train, y_train) 167 | 168 | 169 | y_pred = model.predict(X_test) 170 | print("\n\n--------Decision Tree------------") 171 | print("Confusion matrix Decision Tree:\n",confusion_matrix(y_test, y_pred)) 172 | 173 | plot_confusion_matrix(model, X_test, y_test) 174 | plt.show() 175 | 176 | dtout= round((accuracy_score(y_test, y_pred) * 100),2) 177 | print("Accuracy score for Decision Tree: ", round((accuracy_score(y_test, y_pred) * 100),2)) 178 | return model, dtout 179 | 180 | 181 | 182 | 183 | 184 | # training ML Model 185 | # df = pd.read_csv("data//preprocessed_input_data.csv") 186 | df = pd.read_csv(PREPROCESSED_INPUT_TRAINING_DATA) 187 | df = df.dropna() 188 | print(df.head()) 189 | 190 | # training the vectorizer (conveet text data to number data) 191 | from sklearn.feature_extraction.text import TfidfVectorizer 192 | vectorizer = TfidfVectorizer() 193 | X = vectorizer.fit_transform(df['tweet'].values ) 194 | y = df['depressed'].values 195 | 196 | #save vectorizer object to vectorize user tweets later 197 | # joblib.dump(vectorizer, 'vectorizer.pkl') 198 | joblib.dump(vectorizer, VECTORIZER_FILE) 199 | 200 | 201 | # train test split 202 | from sklearn.model_selection import train_test_split 203 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42) 204 | 205 | 206 | 207 | # checking accruacy of SVM 208 | svm_model, svmout = train_svm(X_train, X_test, y_train, y_test) 209 | 210 | # checking accuracy of Logistic Regression 211 | lr_model, lrout = train_logistic_regression(X_train, X_test, y_train, y_test) 212 | 213 | # checking accuracy of Decision Tree Algorithm 214 | dt_model, dtout = train_decision_tree(X_train, X_test, y_train, y_test) 215 | 216 | 217 | 218 | #PLOTING 219 | 220 | # data = {'SVM':svmout, 'Logistic Regression':lrout, 'Decision Tree':dtout} 221 | # courses = list(data.keys()) 222 | # values = list(data.values()) 223 | 224 | # fig = plt.figure(figsize = (10, 5)) 225 | # # creating the bar plot 226 | # plt.bar(courses, values, color ='maroon', 227 | # width = 0.4) 228 | # plt.xlabel("Tweet") 229 | # plt.ylabel("No. of tweets") 230 | # plt.title("Depression Analysis") 231 | # plt.show() 232 | 233 | x = ['SVM', 'Logistic Regression', 'Decision Tree'] 234 | y = [svmout, lrout, dtout] 235 | color = ['red', 'blue', 'green'] 236 | bars = plt.bar(x, height=y, color=color, width=.5) 237 | xlocs, xlabs = plt.xticks() 238 | # reference x so you don't need to change the range each time x changes 239 | xlocs=[i for i in x] 240 | xlabs=[i for i in x] 241 | plt.xlabel('Model') 242 | plt.ylabel('Accuracy %') 243 | plt.xticks(xlocs, xlabs) 244 | plt.title("Depression Analysis") 245 | 246 | print("\n\n") 247 | for bar in bars: 248 | yval = bar.get_height() 249 | plt.text(bar.get_x(), yval + .5, yval) 250 | 251 | plt.figure(figsize=(15, 15)) 252 | plt.show() 253 | 254 | print("\n\n") 255 | 256 | 257 | # choose SVM Regression based on high accuracy score 258 | model, accuracy_final = train_svm(X_train, X_test, y_train, y_test) 259 | 260 | 261 | # Save the model as a pickle in a file at given location "model.pkl" 262 | #joblib.dump(model, 'model.pkl') 263 | joblib.dump(model, MODEL_FILE) 264 | 265 | 266 | # Load/Read the model from the file at given location "model.pkl" 267 | # classification_model = joblib.load('model.pkl') 268 | classification_model = joblib.load(MODEL_FILE) 269 | 270 | # predicting the model on test data 271 | y_pred=classification_model.predict(X_test) 272 | 273 | # calculate the accuracy 274 | print("\n\n Model accuracy: ", round((accuracy_score(y_test, y_pred) * 100), 2)) 275 | 276 | print("\n\n", confusion_matrix(y_test, y_pred)) 277 | 278 | #PREDICT TWEETS 279 | # twitter dataset scraping based on keyword 280 | 281 | import re 282 | import numpy as np 283 | import tweepy 284 | from tweepy import OAuthHandler 285 | from textblob import TextBlob 286 | 287 | import pandas as pd 288 | from wordcloud import WordCloud 289 | from better_profanity import profanity 290 | import configparser 291 | 292 | import joblib 293 | 294 | def download_user_tweets(): 295 | # set twitter credentials 296 | #insert your API key details 297 | api_key = 'api----key----here' 298 | api_key_secret = 'api------key-------secret--here' 299 | access_token = 'access----token-------here' 300 | access_token_secret = 'access----------token-----secret----here' 301 | 302 | # Access Twitter Data (login to twitter via api) 303 | auth = tweepy.OAuthHandler(api_key, api_key_secret) 304 | auth.set_access_token(access_token, access_token_secret) 305 | api = tweepy.API(auth) 306 | 307 | # read configs 308 | # config = configparser.ConfigParser() 309 | # config.read('config.ini') 310 | # consumer_key = config['twitter']['api_key'] 311 | # consumer_secret = config['twitter']['api_key_secret'] 312 | # access_token = config['twitter']['access_token'] 313 | # access_token_secret = config['twitter']['access_token_secret'] 314 | # authentication 315 | # auth = tweepy.OAuthHandler(api_key, api_key_secret) 316 | # auth.set_access_token(access_token, access_token_secret) 317 | # api = tweepy.API(auth) 318 | 319 | # user tweets 320 | user = input("Enter Twitter username:").strip() 321 | if len(user)<=1: 322 | user = 'elonmusk' 323 | limit=50 324 | 325 | tweets = tweepy.Cursor(api.user_timeline, screen_name=user, count=200, tweet_mode='extended').items(limit) 326 | 327 | # tweets = api.user_timeline(screen_name=user, count=limit, tweet_mode='extended') 328 | 329 | # create DataFrame 330 | columns = ['User', 'tweet'] 331 | data = [] 332 | 333 | for tweet in tweets: 334 | data.append([tweet.user.screen_name, tweet.full_text]) 335 | 336 | df = pd.DataFrame(data, columns=columns) 337 | 338 | # print(df.head()) 339 | # print("\n\n") 340 | # save user tweets to csv 341 | # print("LOGGER: saving user tweets to : ", USER_TWEET_DATA_FILE) 342 | df.to_csv(USER_TWEET_DATA_FILE, index=False) 343 | 344 | return df 345 | 346 | 347 | def predict_user_tweets(df): 348 | 349 | # user tweet preprocessing using NLP : nltk 350 | 351 | df['tweet'] = df['tweet'].astype(str) 352 | #remove leading and ending whitespaces 353 | df['tweet'] = df['tweet'].str.strip() 354 | 355 | # keep only alphabets 356 | df['tweet'] = df['tweet'].apply(keep_alpha) 357 | 358 | # nlp preprocessing to remove stopwords and get base/stem form of each word 359 | df['tweet'] = df['tweet'].apply(nlp_preprocessing) 360 | df['tweet'] = df['tweet'].str.strip() 361 | 362 | # replace empty rows with NAN and then drop them 363 | df['tweet'].replace('', np.nan, inplace=True) 364 | df = df.dropna() 365 | df = df.reset_index(drop=True) 366 | 367 | vectorizer = joblib.load(VECTORIZER_FILE) 368 | X_test = vectorizer.transform(df['tweet'].values ) 369 | 370 | # Load/Read the model from the file at given location "model.pkl" 371 | # classification_model = joblib.load('model.pkl') 372 | classification_model = joblib.load(MODEL_FILE) 373 | 374 | # predicting the model on user test data 375 | y_pred=classification_model.predict(X_test) 376 | 377 | # print(y_pred) 378 | df['prediction'] = y_pred 379 | print(df[['tweet', 'prediction']]) 380 | return list(y_pred) 381 | 382 | 383 | def final_output(predictions): 384 | total = len(predictions) 385 | depressed_count = predictions.count("YES") 386 | 387 | print("\n\n") 388 | 389 | if depressed_count > (total*.6): 390 | print("Result: DEPRESSED 😒") 391 | else: 392 | print("Result: NOT DEPRESSED 😊") 393 | 394 | user_tweets = download_user_tweets() 395 | predictions = predict_user_tweets(user_tweets) 396 | final_output(predictions) 397 | -------------------------------------------------------------------------------- /twitterapiaccount.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": null, 6 | "metadata": { 7 | "id": "X8bRsVp767xc" 8 | }, 9 | "outputs": [], 10 | "source": [ 11 | "from google.colab import drive\n", 12 | "drive.mount('/content/drive')" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": null, 18 | "metadata": { 19 | "colab": { 20 | "base_uri": "https://localhost:8080/" 21 | }, 22 | "id": "DSFmsgVt7qPE", 23 | "outputId": "999b499e-d3c8-4ada-cb81-ed7c33e46f8d" 24 | }, 25 | "outputs": [ 26 | { 27 | "name": "stdout", 28 | "output_type": "stream", 29 | "text": [ 30 | "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n", 31 | "Collecting better_profanity\n", 32 | " Downloading better_profanity-0.7.0-py3-none-any.whl (46 kB)\n", 33 | "\u001b[K |████████████████████████████████| 46 kB 2.1 MB/s \n", 34 | "\u001b[?25hInstalling collected packages: better-profanity\n", 35 | "Successfully installed better-profanity-0.7.0\n" 36 | ] 37 | }, 38 | { 39 | "name": "stderr", 40 | "output_type": "stream", 41 | "text": [ 42 | "[nltk_data] Downloading package punkt to /root/nltk_data...\n", 43 | "[nltk_data] Unzipping tokenizers/punkt.zip.\n", 44 | "[nltk_data] Downloading package stopwords to /root/nltk_data...\n", 45 | "[nltk_data] Unzipping corpora/stopwords.zip.\n", 46 | "[nltk_data] Downloading package wordnet to /root/nltk_data...\n", 47 | "[nltk_data] Downloading package omw-1.4 to /root/nltk_data...\n" 48 | ] 49 | } 50 | ], 51 | "source": [ 52 | "!pip install better_profanity \n", 53 | "import nltk\n", 54 | "\n", 55 | "nltk.download('punkt')\n", 56 | "nltk.download('stopwords')\n", 57 | "nltk.download('wordnet')\n", 58 | "nltk.download('omw-1.4')\n", 59 | "\n", 60 | "\n", 61 | "\n", 62 | "RAW_INPUT_TRAINING_DATA = \"/content/drive/MyDrive/twitterapiaccount/dataset_combined_2510_new.csv\"\n", 63 | "\n", 64 | "\n", 65 | "\n", 66 | "USER_TWEET_DATA_FILE = \"user_tweets.csv\" \n", 67 | "PREPROCESSED_INPUT_TRAINING_DATA = \"preprocessed_input_data.csv\"\n", 68 | "MODEL_FILE = \"model.pkl\"\n", 69 | "VECTORIZER_FILE = \"vectorizer.pkl\"\n", 70 | "\n" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": null, 76 | "metadata": { 77 | "colab": { 78 | "base_uri": "https://localhost:8080/" 79 | }, 80 | "id": "U70IHhO37qR2", 81 | "outputId": "9624348d-4eee-44bd-8a80-ee84997ababd" 82 | }, 83 | "outputs": [ 84 | { 85 | "name": "stdout", 86 | "output_type": "stream", 87 | "text": [ 88 | " index tweet depressed\n", 89 | "0 10197 soooo sunburnt mum earlier wait get fell aslee... NO\n", 90 | "1 24592 even get suicid didnt answer show told viewer ... YES\n", 91 | " index tweet depressed\n", 92 | "37865 26162 got rob laptop award first year achiev year th... YES\n", 93 | "37866 23082 retweet your either gay depress horni hungri l... YES\n", 94 | "YES 23012\n", 95 | "NO 14855\n", 96 | "Name: depressed, dtype: int64\n" 97 | ] 98 | } 99 | ], 100 | "source": [ 101 | "\n", 102 | "#DATA CLEANING: Vectorizer AND NLP\n", 103 | "\n", 104 | "import pandas as pd\n", 105 | "import numpy as np\n", 106 | "import matplotlib.pyplot as plt\n", 107 | "%matplotlib inline\n", 108 | "\n", 109 | "import re\n", 110 | "from sklearn.feature_extraction.text import TfidfVectorizer\n", 111 | "\n", 112 | "#importing nlp packages\n", 113 | "from nltk import stem\n", 114 | "from nltk.corpus import stopwords\n", 115 | "stemmer = stem.SnowballStemmer('english')\n", 116 | "stopwords = set(stopwords.words('english'))\n", 117 | "\n", 118 | "\n", 119 | "#removing the special characters and numbers and url\n", 120 | "def keep_alpha(s): \n", 121 | "# s = row['content']\n", 122 | " non_url = re.sub(r\"http\\S+\", \"\", s)\n", 123 | " res = re.sub('[^a-zA-Z\\s]', '', non_url)\n", 124 | " res1 = re.sub('\\n', '', res)\n", 125 | " return res1\n", 126 | "\n", 127 | "def nlp_preprocessing(msg):\n", 128 | " try:\n", 129 | " # converting messages to lowercase\n", 130 | " msg = msg.lower()\n", 131 | " # removing stopwords\n", 132 | " msg = [word for word in msg.split() if word not in stopwords]\n", 133 | " # using a stemmer (getting root form of each word of each row)\n", 134 | " msg = \" \".join([stemmer.stem(word) for word in msg])\n", 135 | " \n", 136 | " except Exception as e:\n", 137 | " print(e)\n", 138 | "\n", 139 | " return msg\n", 140 | "\n", 141 | "\n", 142 | "df=pd.read_csv(RAW_INPUT_TRAINING_DATA)\n", 143 | "df.rename(columns = {'Text':'tweet'}, inplace = True)\n", 144 | "df = df.dropna()\n", 145 | "df = df.sample(frac=1).reset_index()\n", 146 | "#df = df.sample(frac=0.1).reset_index()\n", 147 | "\n", 148 | "\n", 149 | "# data preprocessing using NLP : nltk\n", 150 | "df['tweet'] = df['tweet'].astype(str)\n", 151 | "#remove leading and ending whitespaces\n", 152 | "df['tweet'] = df['tweet'].str.strip()\n", 153 | "\n", 154 | "# keep only alphabets\n", 155 | "df['tweet'] = df['tweet'].apply(keep_alpha)\n", 156 | "\n", 157 | "# nlp preprocessing to remove stopwords and get base/stem form of each word\n", 158 | "df['tweet'] = df['tweet'].apply(nlp_preprocessing)\n", 159 | "print(df.head(2))\n", 160 | "print(df.tail(2))\n", 161 | "\n", 162 | "\n", 163 | "print(df['depressed'].value_counts())\n", 164 | "\n", 165 | "# df.to_csv(\"data//preprocessed_input_data.csv\", index=False)\n", 166 | "df.to_csv(PREPROCESSED_INPUT_TRAINING_DATA, index=False)\n", 167 | "\n", 168 | "\n" 169 | ] 170 | }, 171 | { 172 | "cell_type": "code", 173 | "execution_count": null, 174 | "metadata": { 175 | "colab": { 176 | "background_save": true, 177 | "base_uri": "https://localhost:8080/" 178 | }, 179 | "id": "zW_UfmPz7qUx", 180 | "outputId": "ab74b338-8c46-446d-e307-25390b76e16b" 181 | }, 182 | "outputs": [ 183 | { 184 | "name": "stdout", 185 | "output_type": "stream", 186 | "text": [ 187 | " index tweet depressed\n", 188 | "0 10197 soooo sunburnt mum earlier wait get fell aslee... NO\n", 189 | "1 24592 even get suicid didnt answer show told viewer ... YES\n", 190 | "2 993 depress YES\n", 191 | "3 35428 hate see peopl depress YES\n", 192 | "4 17374 bright side speak tour come end octob im gonna... YES\n", 193 | "\n", 194 | "\n", 195 | "----SVM------\n", 196 | "Confusion matrix SVM:\n", 197 | " [[2727 324]\n", 198 | " [ 317 3995]]\n" 199 | ] 200 | }, 201 | { 202 | "name": "stderr", 203 | "output_type": "stream", 204 | "text": [ 205 | "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function plot_confusion_matrix is deprecated; Function `plot_confusion_matrix` is deprecated in 1.0 and will be removed in 1.2. Use one of the class methods: ConfusionMatrixDisplay.from_predictions or ConfusionMatrixDisplay.from_estimator.\n", 206 | " warnings.warn(msg, category=FutureWarning)\n" 207 | ] 208 | }, 209 | { 210 | "data": { 211 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUsAAAEGCAYAAADscbcsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3dfZxXZZ3/8dd7hvt7EW8Q8WYRbdESldCyTC0V3Xa1NtNsV9ZsLdMyb0rdfWze9LPS9S43pSzdsK0UuzE00vCmVbZUQNEEI8YMBfEGkHsY5ubz++NcA18HZr5nYM7cfHk/H4/zmHOuc51zrsPAh+vmnOsoIjAzs9ZVdXYBzMy6AwdLM7McHCzNzHJwsDQzy8HB0swshx6dXYDt0WNwv+i16+DOLoa1QY+a2s4ugrXBBtayMWq1Pec44Zj+sWx5Q668s5+vfSgiJmzP9YrSrYNlr10Hc8DNn+nsYlgbDPv7P3d2EawNnopHtvscy5Y38PRDe+XKWz18wbDtvmBBunWwNLOuL4BGGju7GNvNwdLMChUEdZGvGd6VOViaWeFcszQzKyMIGirgtWoHSzMrXCMOlmZmrQqgwcHSzKw81yzNzMoIoM59lmZmrQvCzXAzs7ICGrp/rHSwNLNiZW/wdH8OlmZWMNHAds3F0SU4WJpZobIBHgdLM7NWZc9ZOliamZXV6JqlmVnrXLM0M8shEA0V8AUbB0szK5yb4WZmZQRiY1R3djG2m4OlmRUqeyjdzXAzs7I8wGNmVkaEaAjXLM3Mymp0zdLMrHXZAE/3DzXdv25sZl1a0wBPnqU1kvpIelrSc5LmSroqpf9Q0suS5qRlbEqXpFsk1Uh6XtKhJeeaKGlBWibmuY/uH+7NrMtraJ/nLGuBYyNijaSewAxJv0n7vhIRP2uW/0RgdFoOByYBh0saClwBjCOL5bMlTY2It1u7uGuWZlaopjd48iytniezJm32TEtr0wqfDNyVjnsSGCJpOHACMD0ilqcAOR2YUO4+HCzNrHCNUZVrKUdStaQ5wJtkAe+ptOua1NS+SVLvlDYCeLXk8EUpraX0VjlYmlmhsok0ctcsh0maVbKc845zRTRExFhgT2C8pIOAy4F3Ae8FhgKXFnEf7rM0s0IFoi7/645LI2Jc2XNGrJD0GDAhIq5PybWS/hu4JG0vBkaWHLZnSlsMHN0s/XflrumapZkVKgIaoirX0hpJu0gaktb7AscBf0r9kEgScArwQjpkKnBmGhU/AlgZEUuAh4DjJe0kaSfg+JTWKtcszaxgaq+H0ocDkyVVk1X0pkTEA5IelbQLIGAO8PmUfxpwElADrAPOAoiI5ZK+DsxM+a6OiOXlLu5gaWaFCmiX1x0j4nngkK2kH9tC/gDOa2HfncCdbbm+g6WZFc6T/5qZlRHIk/+amZWTfQq3+4ea7n8HZtbFyfNZmpmVE5Dr7ZyuzsHSzArnmqWZWRkRcs3SzKycbIDHX3c0MyvD3+AxMysrG+Bxn6WZWVl+g8fMrAy/wWNmllO5j5F1Bw6WZlaoCKhrdLA0M2tV1gx3sDQzK8tv8FguVW/VMeCm16la0QDAhgmD2fAPOzHw2teoXlwHgNY2EP2rWXHL3vR8di39Jy+F+oAeYu1Zu1B3cD+0rpHBl23+KF3V0jpqjxnE2n/dtVPua0fRs3cjN/yihp69guoewRO/HsKPrt+dS7+zkNEHr6ehTsyf05dvf3UkDfWbg8L+B6/j5vsX8I1z92bGr4d04h10Lj861AaSArgxIi5O25cAAyLiyrR9DnBRyr4KuCgiZnRE2TpCVIu1n9mFhv36oHWNDLlwIXVj+7H60j025el/x1s09suaKo2Dqln1HyNo3LkH1QtrGfS1Rbw9eRTRr4oVt+y96ZghX15I7fsGdPj97GjqasVXTx3FhnXVVPcIbryvhpmPDuTRX+zEtefvBcBlt73CiWcs44G7hgFQVRWc/e9LmP2/Azuz6F1EZTTDO+oOaoGPSxrWfIekjwKfAz4QEe8i+37GTyTt3kFlK1wM7UHDfn2y9X5V1I/sRdWy+pIMQa8Zq6n9UPYPq2FUHxp3zv4fa9irF9oYUNf4jnNWLd6IVjZQf2DfjrmJHZrYsC57Xa9Hz6C6ZxABMx8dRPbZFzH/2X4MG1636YiTP7OUGdMGs2KpG28Ajek7POWWrqyjgmU9cDtw4Vb2XQp8JSKWAkTEM8BkWvh2RndX9UYdPV6qpf6APpvSesxdT+OQahr36LVF/l6/X0P9qD7Q852/qt6Pr6b2AwNBXfsvWKWoqgpumz6fe56fy7OPD2D+s/037avuEXz4E28z67HsP7udd6/j/Seu5IHJO3dWcbuUbDS8OtfSlXVk3fhW4NOSBjdLPxCY3SxtVkrfgqRzmj7AXr9yXQHFLND6RgZ98zXW/usuRL/NfzF6P76ajUdt2VyrXlhL/x8uZc15W/ZJ9n5ic03UitfYKL5w3AF8+rAxHDB2HXsfsH7Tvi9+cxEvPNmfF57OukQ+f9Vi7rhmOFEB/XTtoemh9DxLV9ZhwTIiVgF3AV/azvPcHhHjImJcj8H92qdwHaE+GPTN19hw9CA2vr8kyDUEvf+whtoPvjPwVS2tY9A3XmP1hbvTOPydNc7ql2tRQ2xq2lvHWbuqmud+P4D3HrMagE9f9DqDd67ne1du7n/e/+D1XD5pIZOfmscHP7qSL35zMe+bsLKzitwltEczXFIfSU9Lek7SXElXpfR9JT0lqUbSPZJ6pfTeabsm7d+n5FyXp/T5kk7Icw8d3aFyM/AM8N8lafOAw4BHS9IOA+Z2YLmKFcGAW16nYWQvNpyy0zt29ZyzjoYRvWgc1nNTmtY0MOiqxaydOIz6MVv2Sfb+31XUbqUmasUYPLSe+nqxdlU1vfo0cuhRa5hy665MOGMZ445ezaWfHPWOWuTEI/520/rFN73CUw8P4g8PNm9Q7TjacTS8Fjg2ItZI6gnMkPQbssHhmyLibknfBc4GJqWfb0fEfpJOB64FTpM0BjidrPW6B/CwpP0joqG1i3dosEwfN59CdhNN3+y9DrhW0oSIWCZpLPAvwOEdWbYi9Zi3gT6PraZ+n14M+dJCANaeuTN14wZkfY/NmtN9fr2C6iV19Lt7Of3uzr79vvLqEcSQ7NfVe8YaVl0xomNvYgc2dLc6Lvn2K1RVQVUVPH7/YJ56eBDTXnmONxb14ub7FwDwf9MG8+ObKmZcsl21x2h4+g74mrTZMy0BHAuckdInA1eSBcuT0zrAz4DvSFJKvzsiaoGXJdUA44E/tHb9zhiquwE4v2kjIqZKGgH8Pj1itBr4p4hY0gllK0T9gX1Zev/+W9235sIt/3GtP21n1p/W8uDA2z/Yt93KZuW9/GJfzjv+gC3ST9rr4LLH3nDhXkUUqVuJEPX5g+UwSbNKtm+PiNubNiRVk41x7Ec2DvISsCIimh4vWQQ01SRGAK9mZYh6SSuBnVP6kyXXKD2mRR0SLCNiQMn6G0C/Zvsnkf1PYGYVqA3N8KURMa6lnampPFbSEOCXwLvaoXi5dP8nRc2sS2vqs2zP0fCIWAE8BrwPGCKpqeK3J7A4rS8GRgKk/YOBZaXpWzmmRQ6WZla49giWknZJNUok9QWOA14kC5qfSNkmAr9K61PTNmn/o6nfcypwehot3xcYDTxd7h78eoGZFaodJ/8dDkxO/ZZVwJSIeEDSPOBuSf8PeBa4I+W/A/hRGsBZTjYCTkTMTQPN88hemDmv3Eg4OFiaWQdoj1cZI+J54JCtpP+FbDS7efoG4NQWznUNcE1bru9gaWaFioB6T/5rZlZeV3+VMQ8HSzMrlD9YZmaWUyVMKuJgaWaF6+pzVebhYGlmhYpwn6WZWQ6iwaPhZmbluc/SzKwMf93RzCyPyPotuzsHSzMrnEfDzczKCA/wmJnl42a4mVkOHg03MysjwsHSzCwXPzpkZpaD+yzNzMoIRKNHw83MyquAiqWDpZkVzAM8ZmY5VUDVsvt3JJhZlxehXEs5kkZKekzSPElzJV2Q0q+UtFjSnLScVHLM5ZJqJM2XdEJJ+oSUViPpsnLXbrFmKem/aOX/g4j4Utk7M7MdXgCNje3WDK8HLo6IZyQNBGZLmp723RQR15dmljSG7HvhBwJ7AA9L2j/tvhU4DlgEzJQ0NSLmtXTh1prhs7btXszMSgTQTn2WEbEEWJLWV0t6ERjRyiEnA3dHRC3wsqQaNn9jvCZ9cxxJd6e8bQ+WETG5dFtSv4hYl+N+zMzeoQ3PWQ6TVFpRuz0ibt9aRkn7AIcATwFHAudLOpOsondxRLxNFkifLDlsEZuD66vN0g9vrWBl+ywlvU/SPOBPaftgSbeVO87MbJPIucDSiBhXsrQUKAcAPwe+HBGrgEnAKGAsWc3zhva+hTwDPDcDJwDLACLiOeCo9i6ImVWqfIM7eR8vktSTLFD+OCJ+ARARb0REQ0Q0At9nc1N7MTCy5PA9U1pL6S3KNRoeEa82S2rIc5yZGdCWmmWrJAm4A3gxIm4sSR9eku1jwAtpfSpwuqTekvYFRgNPAzOB0ZL2ldSLbBBoamvXzvOc5auS3g9EiugXAC/mOM7MLHsovf1Gw48E/hn4o6Q5Ke3fgE9JGptdjb8CnwOIiLmSppAN3NQD50VEA4Ck84GHgGrgzoiY29qF8wTLzwPfJusUfS2d/Ly23J2Z7ejabTR8Rgsnm9bKMdcA12wlfVprxzVXNlhGxFLg03lPaGa2hR3hDR5JfyPpfklvSXpT0q8k/U1HFM7MKkQ79Vl2pjwDPD8BpgDDyZ6Avxf4aZGFMrMK0vRQep6lC8sTLPtFxI8ioj4t/wP0KbpgZlY5IvItXVlr74YPTau/SS+Z3032f8RptKFT1MyM9hsN7zStDfDMJguOTXf5uZJ9AVxeVKHMrLKoi9ca82jt3fB9O7IgZlahusHgTR65Jv+VdBAwhpK+yoi4q6hCmVkl6fqDN3mUDZaSrgCOJguW04ATgRmAg6WZ5VMBNcs8o+GfAD4MvB4RZwEHA4MLLZWZVZbGnEsXlqcZvj4iGiXVSxoEvMk7Z+swM2tZO07+25nyBMtZkoaQTXs0G1gD/KHQUplZRano0fAmEfGFtPpdSQ8CgyLi+WKLZWYVpZKDpaRDW9sXEc8UUyQzs66ntZpla9OyB3BsO5elzXrU1DLs7//c2cWwNnjotTnlM1mXMf6E9vnsVkU3wyPimI4siJlVqKDiX3c0M2sflVyzNDNrLxXdDDczazcVECzzzJQuSf8k6Wtpey9J48sdZ2a2yQ4yU/ptwPuAT6Xt1cCthZXIzCqKIv9S9lzSSEmPSZonaa6kC1L6UEnTJS1IP3dK6ZJ0i6QaSc+XPhIpaWLKv0DSxHLXzhMsD4+I84ANABHxNtArx3FmZplG5VvKqwcujogxwBHAeZLGAJcBj0TEaOCRtA3ZxD+j03IOMAk2TW5+BXA4MB64oinAtiRPsKyTVE2qJEvahS7/yruZdSXtVbOMiCVNL8RExGrgRbLPdJ8MTE7ZJgOnpPWTgbsi8yQwRNJw4ARgekQsTxXA6cCE1q6dJ1jeAvwS2FXSNWTTs30jx3FmZpn8fZbDJM0qWc5p6ZSS9gEOAZ4CdouIJWnX68BuaX0E8GrJYYtSWkvpLcrzbviPJc0mm6ZNwCkR8WK548zMAMhZa0yWRsS4cpkkDQB+Dnw5IlZJm5vwERFS+z+slGc0fC9gHXA/MBVYm9LMzPJpx9FwST3JAuWPI+IXKfmN1Lwm/XwzpS/mnVNK7pnSWkpvUZ5m+K+BB9LPR4C/AL/JcZyZGQBqzLeUPU9WhbwDeDEibizZNRVoGtGeCPyqJP3MNCp+BLAyNdcfAo6XtFMa2Dk+pbUoTzP83c0KeyjwhRaym5kV6Ujgn4E/SmqaleXfgG8BUySdDSwEPpn2TQNOAmrIWshnAUTEcklfB2amfFdHxPLWLtzmN3gi4hlJh7f1ODPbgbVTD2JEzGDz57mb+/BW8gdwXgvnuhO4M++183yw7KKSzSrgUOC1vBcwsx1c2wZ4uqw8NcuBJev1ZH2XPy+mOGZWkSo9WKaH0QdGxCUdVB4zq0SVHCwl9YiIeklHdmSBzKyyiHwj3V1dazXLp8n6J+dImgrcC6xt2lnyfJOZWct2oD7LPsAysm/uBNl/FAE4WJpZPhUeLHdNI+EvsDlINqmAWzezDlMBEaO1YFkNDGDrzzRVwK2bWUep9Gb4koi4usNKYmaVq8KDZff/dqWZdb6o/NHwLV4dMjPbJpVcsyz3UrmZWV6V3mdpZtY+HCzNzMroBp+5zcPB0swKJdwMNzPLxcHSzCwPB0szsxwcLM3MytiBZh0yM9s+DpZmZuVVwuuOeb4bbma2XRT5lrLnke6U9KakF0rSrpS0WNKctJxUsu9ySTWS5ks6oSR9QkqrkXRZnntwsDSzYkUblvJ+CEzYSvpNETE2LdMAJI0BTgcOTMfcJqk6fVvsVuBEYAzwqZS3VW6Gm1nx2u+74Y9L2idn9pOBuyOiFnhZUg0wPu2riYi/AEi6O+Wd19rJXLM0s0I1vcGTsxk+TNKskuWcnJc5X9LzqZm+U0obAbxakmdRSmspvVWuWZpZ4dSYu2q5NCLGtfH0k4Cvk9Vfvw7cAHymjecoy8HSzIpV8EQaEfFG07qk7wMPpM3FwMiSrHumNFpJb5Gb4WZWuPYaDd/quaXhJZsfI/vIIsBU4HRJvSXtC4wm+8T3TGC0pH0l9SIbBJpa7jquWZpZ8dqpZinpp8DRZH2bi4ArgKMljU1X+SvwOYCImCtpCtnATT1wXkQ0pPOcDzxE9mHGOyNibrlrO1iaWeHa63XHiPjUVpLvaCX/NcA1W0mfBkxry7UdLM2seH7d0cysjB3g645mZtvNM6WbmeUV3T9aOliaWeFcs7Q269m7kRt+UUPPXkF1j+CJXw/hR9fvzj+ctZSPffYt9th3I6cedCCrlme/mk+c+ybHfvxtAKqrYeToDZz27gNZvcK/uiJt3CAu/vh+1G2soqEePvh3KznzK68zZ8YAvn/1HtTVidHvWc9FN7xCdQ9YvaKaGy8ayZKFvenZu5GLb3yVfd61AYAzx4+h74AGqqqgukfwnQf/3Ml318H8dceWSRLwBHBNRPwmpZ0KnA0cB/yxJPvdEfEtSR8le1WpCugJfDsivldE+TpTXa346qmj2LCumuoewY331TDz0YHMndmPp6aP4rqf17wj/88m7crPJu0KwOHHreTj/7rUgbID9OwdXHfvS/Tt30h9HVx0ymgOO3oV/3nBXlw75SX2HFXL5Ot2Z/qUoUw4Yzl337Ibow5czxV3/pVXFvTm1n/fk2unvLTpfNfdW8PgnRs68Y46lwd4WhARIenzwL2SHkvX+QbZNEnPRcTY0vySegK3A+MjYpGk3sA+RZSt84kN66oB6NEzqO4ZRMBLL/Qre+Qxp6zgd/cNKbqABkjQt3/2L7y+TjTUiepq6Nkr2HNULQCHfmg19/zXbkw4YzmvLOjNJ89/E4C9Rtfyxqu9ePutHuy0S32n3UNXUgnBsrDXHSPiBeB+4FLga8BdEfFSC9kHkgXUZenY2oiYX1TZOltVVXDb9Pnc8/xcnn18APOf7V/2mN59Gxl39GpmTBvcASU0gIYGOPcjB3Daew7ikKNWc8Ah62ioF39+ri8AMx4Ywluv9QRg3zEb+L/0u/nTs/14Y1Evli7J9qHg3z41ivNO2J9p/7Nzp9xLpwqyAZ48SxdWdHvuKuAZYCPQNJNIX0lzSvJ8MyLukTQVWCjpEbIX4X8aEVv8f5SmbDoHoA/la2NdUWOj+MJxB9B/UANX3PEyex+wnoXz+7Z6zBHHrWTurP5ugneg6mqY9PB81qys5qqz92Hh/D5cPumvfPeKEdRtFId9aDVVqbpx2vlvMOk/RnDuRw5g379dz34Hrd+078b7ahg2vI4VS3tw2emjGLnfBt59xNrOu7FO4AGeMiJiraR7gDVpAk6A9c2b4SnvZyW9G/gIcAlZ3+a/bCXf7WRNdgZpaLf+FaxdVc1zvx/Ae49ZXTZYfuhkN8E7y4DBDRz8/jXMfGwgp577Fjfel/Urz/7dQBb9pTcA/Qc2csnN2RSJETDx8DHsvnf2V37Y8DoAhgyr58gJK/nTs/12uGBZCQM8HTHrUGNayoqIP0bETWSB8h8LLVUnGTy0nv6Dso7+Xn0aOfSoNbxa06fVY/oNbOA9R6zl9w8O6ogiGrBiWTVrVmZ9y7XrxTOPD2TkfrWsWJrVLzbWiim37cpH/3kZAGtWVlO3UQD85idDOeiINfQf2MiGdVWsW5P9M9uwrorZ/ztw0yj5jqKNk/92WV2iTSdpADAuIn6XksYCCzuvRMUZulsdl3z7FaqqoKoKHr9/ME89PIiTz36LU899i6G71vHdh+fz9KODuPmSbMq9I09cyezHB1K7vrqTS7/jWP5GT66/YC8aG0VjIxz19ys44rhVfP/qPXjq4UFEI/zdxGWM/cAaAF5Z0Jvrv7wXAvY+YAMX3pDVMt9+qwdXnb0vAA31cMzHVvDeY1Z31m11joi2TP7bZSkK7lSVdCVZM/z6tN3AOx8depBsVpB7gFHAemAtcEFEzGrt3IM0NA7Xh4sothXkodfmlM9kXcb4E15l1nMbtD3nGDhkzzjkqAty5X3i/q/O3oaZ0jtE4TXLiLiy2XZL1aOTWkg3s26uqzex8+gSzXAzq2ABVEAz3MHSzIrX/WOlg6WZFc/NcDOzHCphNNzB0syKVSGzDvlTuGZWqOyh9Mi1lD2XdKekNyW9UJI2VNJ0SQvSz51SuiTdIqlG0vOSDi05ZmLKv0DSxDz34WBpZsVrzLmU90Oy2ctKXQY8EhGjgUfSNsCJZN8KH002n8QkyIIr2Sd0DwfGA1c0BdjWOFiaWeHaq2YZEY8Dy5slnwxMTuuTgVNK0u+KzJPAEEnDgROA6RGxPCLeBqazZQDegvsszaxYbeuzHCap9M2929PkOa3ZLSKWpPXXgd3S+gjg1ZJ8i1JaS+mtcrA0s4K16d3wpdvzumOaeLyQ4SQ3w82seMVO/vtGal6Tfr6Z0hcDI0vy7ZnSWkpvlYOlmRUrss9K5Fm20VSgaUR7IvCrkvQz06j4EcDK1Fx/CDhe0k5pYOf4lNYqN8PNrHjtNLuZpJ8CR5P1bS4iG9X+FjBF0tlkUzt+MmWfRjZBTw2wDjgrK0osl/R1YGbKd3VENB802oKDpZkVr516ESPiUy3s2mKuxsjmnzyvhfPcCdzZlms7WJpZ4dTY/T/v6GBpZsUK8j5w3qU5WJpZoUS+B867OgdLMyueg6WZWQ4OlmZmZbjP0swsH4+Gm5mVtV2vMnYZDpZmVqzAwdLMLJfu3wp3sDSz4vk5SzOzPBwszczKiICG7t8Od7A0s+K5ZmlmloODpZlZGQHk/wZPl+VgaWYFCwj3WZqZtS7wAI+ZWS7uszQzy8HB0sysnMqYSMPfDTezYgXQ2JhvyUHSXyX9UdIcSbNS2lBJ0yUtSD93SumSdIukGknPSzp0W2/DwdLMiheRb8nvmIgYGxHj0vZlwCMRMRp4JG0DnAiMTss5wKRtvQUHSzMrWHrdMc+y7U4GJqf1ycApJel3ReZJYIik4dtyAQdLMytWQERjrgUYJmlWyXLO1s/IbyXNLtm/W0QsSeuvA7ul9RHAqyXHLkppbeYBHjMrXv43eJaWNK1b8oGIWCxpV2C6pD+V7oyIkNTuI0quWZpZ8dqxzzIiFqefbwK/BMYDbzQ1r9PPN1P2xcDIksP3TGlt5mBpZsWKaLfRcEn9JQ1sWgeOB14ApgITU7aJwK/S+lTgzDQqfgSwsqS53iZuhptZ8drvOcvdgF9Kgix+/SQiHpQ0E5gi6WxgIfDJlH8acBJQA6wDztrWCztYmlnBgmhoaJ8zRfwFOHgr6cuAD28lPYDz2uPaDpZmVixP0WZmlpOnaDMza10A4ZqlmVkZ4cl/zcxyaa8Bns6k6MZTJ0l6i+wxgUozDFja2YWwNqnU39neEbHL9pxA0oNkfz55LI2ICdtzvaJ062BZqSTNyvHKl3Uh/p1VPr/BY2aWg4OlmVkODpZd0+2dXQBrM//OKpz7LM3McnDN0swsBwdLM7McHCw7iaSQdEPJ9iWSrizZPkfSn9LytKQPdEpBd3BpHsQZkk4sSTtV0oOSGtIXBpuWy9L+j0p6VtJzkuZJ+lzn3YG1F/dZdhJJG4AlwHsjYqmkS4ABEXGlpI8CVwEnpH2HAvcB4yPi9U4s9g5J0kHAvcAhZG+9PQtMAJ6LiAHN8vYke1FifEQsktQb2Cci5ndwsa2duWbZeerJRlAv3Mq+S4GvRMRSgIh4huyLde0yL5+1TUS8ANxP9nv5GtnXAl9qIftAsoC6LB1b60BZGfxueOe6FXhe0nXN0g8EZjdLm8XmafOt410FPANsBJre1OkraU5Jnm9GxD2SpgILJT0CPAD8NKICZpLYwTlYdqKIWCXpLuBLwPrOLo+1LCLWSroHWBMRtSl5fUSM3Urez0p6N/AR4BLgOOBfOqywVgg3wzvfzcDZQP+StHnAYc3yHQbM7ahC2VY1pqWsiPhjRNxEFij/sdBSWYdwsOxkEbEcmEIWMJtcB1wraWcASWPJaia3dXgBrU0kDZB0dEnSWCpzZqwdjpvhXcMNwPlNGxExVdII4PfpY/GrgX/a1k94WmGa91k+CFwDfFXS98i6VtbiJnhF8KNDZmY5uBluZpaDg6WZWQ4OlmZmOThYmpnl4GBpZpaDg2UFK5kV5wVJ90rqtx3n+qGkT6T1H0ga00reoyW9fxuu8VdJW3wFsKX0ZnnWtPFaV6bJS8xycbCsbOsjYmxEHET2TvPnS3dK2qbnbCPisxExr5UsRwNtDpZmXZmD5Y7jCWC/VOt7Ik32ME9StaT/lDRT0vNNcy+meRy/I2m+pIeBXZtOJOl3ksal9QmSnklzNz4iaR+yoHxhqtV+UNIukn6erjFT0pHp2J0l/VbSXEk/AFTuJiTdJ2l2OuacZvtuSumPSNolpY1Kc0/OTvf9rvb4w7Qdj9/g2QGkGuSJZG+YABwKHBQRL6eAszIi3pvmXvw/Sb8lm0cREugAAAIISURBVLvxAGAMsBvZ++p3NjvvLsD3gaPSuYZGxHJJ3yWbcOL6lO8nwE0RMUPSXsBDwN8CVwAzIuJqSX/HO1/5bMln0jX6AjMl/TwilpG9Wz8rIi6U9LV07vPJpsH7fEQskHQ42Sujx27DH6Pt4BwsK1vp63hPAHeQNY+fjoiXU/rxwHua+iOBwcBo4CiyqcUagNckPbqV8x8BPN50rvSe+9Z8BBgjbao4DpI0IF3j4+nYX0t6O8c9fUnSx9L6yFTWZWQTXNyT0v8H+EW6xvuBe0uu3TvHNcy24GBZ2baYQiwFjbWlScAXI+KhZvlOasdyVAFHRMSGrZQltzRBxUeA90XEOkm/A/q0kD3SdVdsbRo1s7Zyn6U9BJybPoeApP0l9QceB05LfZrDgWO2cuyTwFGS9k3HDk3pq8lmDG/yW+CLTRtpFiXSNc5IaScCO5Up62Dg7RQo30VWs21SBTTVjs8ga96vAl6WdGq6hiQdXOYaZlvlYGk/IOuPfEbSC8D3yFocvwQWpH13AX9ofmBEvAWcQ9bkfY7NzeD7gY81DfCQTW48Lg0gzWPzqPxVZMF2Lllz/JUyZX0Q6CHpReBbZMG6yVpgfLqHY4GrU/qngbNT+eYCJ+f4MzHbgmcdMjPLwTVLM7McHCzNzHJwsDQzy8HB0swsBwdLM7McHCzNzHJwsDQzy+H/A7PDtFoMFDA4AAAAAElFTkSuQmCC\n", 212 | "text/plain": [ 213 | "
" 214 | ] 215 | }, 216 | "metadata": {}, 217 | "output_type": "display_data" 218 | }, 219 | { 220 | "name": "stdout", 221 | "output_type": "stream", 222 | "text": [ 223 | "Accuracy score for SVM: 91.29\n", 224 | "\n", 225 | "\n", 226 | "-----------Logistic Regression-----\n", 227 | "Confusion matrix Logistic Regression:\n", 228 | " [[2682 369]\n", 229 | " [ 336 3976]]\n" 230 | ] 231 | }, 232 | { 233 | "name": "stderr", 234 | "output_type": "stream", 235 | "text": [ 236 | "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function plot_confusion_matrix is deprecated; Function `plot_confusion_matrix` is deprecated in 1.0 and will be removed in 1.2. Use one of the class methods: ConfusionMatrixDisplay.from_predictions or ConfusionMatrixDisplay.from_estimator.\n", 237 | " warnings.warn(msg, category=FutureWarning)\n" 238 | ] 239 | }, 240 | { 241 | "data": { 242 | "image/png": "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\n", 243 | "text/plain": [ 244 | "
" 245 | ] 246 | }, 247 | "metadata": {}, 248 | "output_type": "display_data" 249 | }, 250 | { 251 | "name": "stdout", 252 | "output_type": "stream", 253 | "text": [ 254 | "Accuracy score for Logistic regression: 90.43\n", 255 | "\n", 256 | "\n", 257 | "--------Decision Tree------------\n", 258 | "Confusion matrix Decision Tree:\n", 259 | " [[2662 389]\n", 260 | " [ 463 3849]]\n" 261 | ] 262 | }, 263 | { 264 | "name": "stderr", 265 | "output_type": "stream", 266 | "text": [ 267 | "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function plot_confusion_matrix is deprecated; Function `plot_confusion_matrix` is deprecated in 1.0 and will be removed in 1.2. Use one of the class methods: ConfusionMatrixDisplay.from_predictions or ConfusionMatrixDisplay.from_estimator.\n", 268 | " warnings.warn(msg, category=FutureWarning)\n" 269 | ] 270 | }, 271 | { 272 | "data": { 273 | "image/png": "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\n", 274 | "text/plain": [ 275 | "
" 276 | ] 277 | }, 278 | "metadata": {}, 279 | "output_type": "display_data" 280 | }, 281 | { 282 | "name": "stdout", 283 | "output_type": "stream", 284 | "text": [ 285 | "Accuracy score for Decision Tree: 88.43\n", 286 | "\n", 287 | "\n", 288 | "\n" 289 | ] 290 | }, 291 | { 292 | "data": { 293 | "image/png": "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\n", 294 | "text/plain": [ 295 | "
" 296 | ] 297 | }, 298 | "metadata": {}, 299 | "output_type": "display_data" 300 | }, 301 | { 302 | "data": { 303 | "text/plain": [ 304 | "
" 305 | ] 306 | }, 307 | "metadata": {}, 308 | "output_type": "display_data" 309 | }, 310 | { 311 | "name": "stdout", 312 | "output_type": "stream", 313 | "text": [ 314 | "\n", 315 | "\n", 316 | "\n", 317 | "\n", 318 | "\n", 319 | "----SVM------\n", 320 | "Confusion matrix SVM:\n", 321 | " [[2727 324]\n", 322 | " [ 317 3995]]\n" 323 | ] 324 | }, 325 | { 326 | "name": "stderr", 327 | "output_type": "stream", 328 | "text": [ 329 | "/usr/local/lib/python3.7/dist-packages/sklearn/utils/deprecation.py:87: FutureWarning: Function plot_confusion_matrix is deprecated; Function `plot_confusion_matrix` is deprecated in 1.0 and will be removed in 1.2. Use one of the class methods: ConfusionMatrixDisplay.from_predictions or ConfusionMatrixDisplay.from_estimator.\n", 330 | " warnings.warn(msg, category=FutureWarning)\n" 331 | ] 332 | }, 333 | { 334 | "data": { 335 | "image/png": "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\n", 336 | "text/plain": [ 337 | "
" 338 | ] 339 | }, 340 | "metadata": {}, 341 | "output_type": "display_data" 342 | }, 343 | { 344 | "name": "stdout", 345 | "output_type": "stream", 346 | "text": [ 347 | "Accuracy score for SVM: 91.29\n", 348 | "\n", 349 | "\n", 350 | " Model accuracy: 91.29\n", 351 | "\n", 352 | "\n", 353 | " [[2727 324]\n", 354 | " [ 317 3995]]\n" 355 | ] 356 | } 357 | ], 358 | "source": [ 359 | "\n", 360 | "\n", 361 | "import pandas as pd\n", 362 | "from sklearn import metrics\n", 363 | "from sklearn.metrics import confusion_matrix \n", 364 | "from sklearn.metrics import accuracy_score \n", 365 | "from sklearn.metrics import plot_confusion_matrix\n", 366 | "\n", 367 | "\n", 368 | "# to save or to load model\n", 369 | "import joblib\n", 370 | "\n", 371 | "svmout=0\n", 372 | "lrout=0\n", 373 | "dtout=0\n", 374 | "\n", 375 | "## SVM\n", 376 | "def train_svm(X_train, X_test, y_train, y_test):\n", 377 | " \n", 378 | " from sklearn import svm \n", 379 | " svm = svm.SVC(C=1000)\n", 380 | " \n", 381 | " # training svm model\n", 382 | " svm.fit(X_train, y_train)\n", 383 | " \n", 384 | " print(\"\\n\\n----SVM------\")\n", 385 | " y_pred = svm.predict(X_test)\n", 386 | " print(\"Confusion matrix SVM:\\n\", confusion_matrix(y_test, y_pred))\n", 387 | "\n", 388 | " plot_confusion_matrix(svm, X_test, y_test) \n", 389 | " plt.show()\n", 390 | "\n", 391 | " svmout=round((accuracy_score(y_test, y_pred) * 100),2)\n", 392 | " # calculate the accuracy\n", 393 | " print(\"Accuracy score for SVM: \", round((accuracy_score(y_test, y_pred) * 100),2))\n", 394 | "\n", 395 | " return svm, svmout\n", 396 | "\n", 397 | " \n", 398 | " \n", 399 | "## Logistic regression\n", 400 | "def train_logistic_regression(X_train, X_test, y_train, y_test):\n", 401 | " from sklearn.linear_model import LogisticRegression \n", 402 | " # Create an instance of the model. \n", 403 | " logreg = LogisticRegression() \n", 404 | " # Training the model. \n", 405 | " logreg.fit(X_train,y_train)\n", 406 | " \n", 407 | " #Do prediction. \n", 408 | " y_pred=logreg.predict(X_test)\n", 409 | " \n", 410 | " print(\"\\n\\n-----------Logistic Regression-----\")\n", 411 | " print(\"Confusion matrix Logistic Regression:\\n\",confusion_matrix(y_test, y_pred))\n", 412 | " \n", 413 | " plot_confusion_matrix(logreg, X_test, y_test) \n", 414 | " plt.show()\n", 415 | "\n", 416 | " lrout=round((accuracy_score(y_test, y_pred) * 100),2)\n", 417 | " # calculate the accuracy \n", 418 | " print(\"Accuracy score for Logistic regression: \", round((accuracy_score(y_test, y_pred) * 100),2))\n", 419 | " return logreg, lrout\n", 420 | "\n", 421 | "\n", 422 | "\n", 423 | "## Decision Tree\n", 424 | "def train_decision_tree(X_train, X_test, y_train, y_test):\n", 425 | " from sklearn.tree import DecisionTreeClassifier\n", 426 | " model = DecisionTreeClassifier()\n", 427 | " model.fit(X_train, y_train)\n", 428 | " \n", 429 | "\n", 430 | " y_pred = model.predict(X_test)\n", 431 | " print(\"\\n\\n--------Decision Tree------------\")\n", 432 | " print(\"Confusion matrix Decision Tree:\\n\",confusion_matrix(y_test, y_pred))\n", 433 | "\n", 434 | " plot_confusion_matrix(model, X_test, y_test) \n", 435 | " plt.show()\n", 436 | "\n", 437 | " dtout= round((accuracy_score(y_test, y_pred) * 100),2)\n", 438 | " print(\"Accuracy score for Decision Tree: \", round((accuracy_score(y_test, y_pred) * 100),2))\n", 439 | " return model, dtout\n", 440 | "\n", 441 | "\n", 442 | "\n", 443 | "\n", 444 | "\n", 445 | "# training ML Model \n", 446 | "# df = pd.read_csv(\"data//preprocessed_input_data.csv\")\n", 447 | "df = pd.read_csv(PREPROCESSED_INPUT_TRAINING_DATA)\n", 448 | "df = df.dropna()\n", 449 | "print(df.head())\n", 450 | "\n", 451 | "# training the vectorizer (conveet text data to number data)\n", 452 | "from sklearn.feature_extraction.text import TfidfVectorizer\n", 453 | "vectorizer = TfidfVectorizer()\n", 454 | "X = vectorizer.fit_transform(df['tweet'].values )\n", 455 | "y = df['depressed'].values\n", 456 | "\n", 457 | "#save vectorizer object to vectorize user tweets later\n", 458 | "# joblib.dump(vectorizer, 'vectorizer.pkl')\n", 459 | "joblib.dump(vectorizer, VECTORIZER_FILE)\n", 460 | "\n", 461 | "\n", 462 | "# train test split\n", 463 | "from sklearn.model_selection import train_test_split\n", 464 | "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 42)\n", 465 | "\n", 466 | "\n", 467 | "\n", 468 | "# checking accruacy of SVM\n", 469 | "svm_model, svmout = train_svm(X_train, X_test, y_train, y_test)\n", 470 | "\n", 471 | "# checking accuracy of Logistic Regression\n", 472 | "lr_model, lrout = train_logistic_regression(X_train, X_test, y_train, y_test)\n", 473 | "\n", 474 | "# checking accuracy of Decision Tree Algorithm\n", 475 | "dt_model, dtout = train_decision_tree(X_train, X_test, y_train, y_test)\n", 476 | "\n", 477 | "\n", 478 | "\n", 479 | "#PLOTING\n", 480 | "\n", 481 | "# data = {'SVM':svmout, 'Logistic Regression':lrout, 'Decision Tree':dtout}\n", 482 | "# courses = list(data.keys())\n", 483 | "# values = list(data.values())\n", 484 | "\n", 485 | "# fig = plt.figure(figsize = (10, 5))\n", 486 | "# # creating the bar plot\n", 487 | "# plt.bar(courses, values, color ='maroon',\n", 488 | "# \t\twidth = 0.4)\n", 489 | "# plt.xlabel(\"Tweet\")\n", 490 | "# plt.ylabel(\"No. of tweets\")\n", 491 | "# plt.title(\"Depression Analysis\")\n", 492 | "# plt.show()\n", 493 | "\n", 494 | "x = ['SVM', 'Logistic Regression', 'Decision Tree']\n", 495 | "y = [svmout, lrout, dtout]\n", 496 | "color = ['red', 'blue', 'green']\n", 497 | "bars = plt.bar(x, height=y, color=color, width=.5)\n", 498 | "xlocs, xlabs = plt.xticks()\n", 499 | "# reference x so you don't need to change the range each time x changes\n", 500 | "xlocs=[i for i in x]\n", 501 | "xlabs=[i for i in x]\n", 502 | "plt.xlabel('Model')\n", 503 | "plt.ylabel('Accuracy %')\n", 504 | "plt.xticks(xlocs, xlabs)\n", 505 | "plt.title(\"Depression Analysis\")\n", 506 | "\n", 507 | "print(\"\\n\\n\")\n", 508 | "for bar in bars:\n", 509 | " yval = bar.get_height()\n", 510 | " plt.text(bar.get_x(), yval + .5, yval)\n", 511 | "\n", 512 | "plt.figure(figsize=(15, 15))\n", 513 | "plt.show()\n", 514 | "\n", 515 | "print(\"\\n\\n\")\n", 516 | "\n", 517 | "\n", 518 | "# choose SVM Regression based on high accuracy score\n", 519 | "model, accuracy_final = train_svm(X_train, X_test, y_train, y_test)\n", 520 | "\n", 521 | "\n", 522 | "# Save the model as a pickle in a file at given location \"model.pkl\"\n", 523 | "#joblib.dump(model, 'model.pkl')\n", 524 | "joblib.dump(model, MODEL_FILE)\n", 525 | "\n", 526 | "\n", 527 | "# Load/Read the model from the file at given location \"model.pkl\"\n", 528 | "# classification_model = joblib.load('model.pkl')\n", 529 | "classification_model = joblib.load(MODEL_FILE)\n", 530 | "\n", 531 | "# predicting the model on test data\n", 532 | "y_pred=classification_model.predict(X_test)\n", 533 | "\n", 534 | "# calculate the accuracy \n", 535 | "print(\"\\n\\n Model accuracy: \", round((accuracy_score(y_test, y_pred) * 100), 2))\n", 536 | "\n", 537 | "print(\"\\n\\n\", confusion_matrix(y_test, y_pred))\n", 538 | "\n", 539 | "\n", 540 | "\n" 541 | ] 542 | }, 543 | { 544 | "cell_type": "code", 545 | "execution_count": null, 546 | "metadata": { 547 | "id": "RSuxIzzD7qZE" 548 | }, 549 | "outputs": [], 550 | "source": [ 551 | "#PREDICT TWEETS\n", 552 | "# twitter dataset scraping based on keyword\n", 553 | "\n", 554 | "import re \n", 555 | "import numpy as np\n", 556 | "import tweepy \n", 557 | "from tweepy import OAuthHandler \n", 558 | "from textblob import TextBlob \n", 559 | "\n", 560 | "import pandas as pd\n", 561 | "from wordcloud import WordCloud\n", 562 | "from better_profanity import profanity\n", 563 | "import configparser\n", 564 | "\n", 565 | "import joblib\n", 566 | "\n", 567 | "def download_user_tweets():\n", 568 | " # set twitter credentials \n", 569 | " api_key = 'Replace you Twitter API key'\n", 570 | " api_key_secret = 'Replace you Twitter API key secret'\n", 571 | " access_token = 'Replace you Twitter access token'\n", 572 | " access_token_secret = 'Replace you Twitter access token secret'\n", 573 | " \n", 574 | " # Access Twitter Data (login to twitter via api) \n", 575 | " auth = tweepy.OAuthHandler(api_key, api_key_secret)\n", 576 | " auth.set_access_token(access_token, access_token_secret)\n", 577 | " api = tweepy.API(auth)\n", 578 | " \n", 579 | " # read configs\n", 580 | " # config = configparser.ConfigParser()\n", 581 | " # config.read('config.ini') \n", 582 | " # consumer_key = config['twitter']['api_key']\n", 583 | " # consumer_secret = config['twitter']['api_key_secret'] \n", 584 | " # access_token = config['twitter']['access_token']\n", 585 | " # access_token_secret = config['twitter']['access_token_secret'] \n", 586 | " # authentication\n", 587 | " # auth = tweepy.OAuthHandler(api_key, api_key_secret)\n", 588 | " # auth.set_access_token(access_token, access_token_secret) \n", 589 | " # api = tweepy.API(auth)\n", 590 | " \n", 591 | " # user tweets\n", 592 | " user = input(\"Enter Twitter username:\").strip()\n", 593 | " if len(user)<=1:\n", 594 | " user = 'elonmusk'\n", 595 | " limit=50\n", 596 | " \n", 597 | " tweets = tweepy.Cursor(api.user_timeline, screen_name=user, count=200, tweet_mode='extended').items(limit)\n", 598 | " \n", 599 | " # tweets = api.user_timeline(screen_name=user, count=limit, tweet_mode='extended')\n", 600 | " \n", 601 | " # create DataFrame\n", 602 | " columns = ['User', 'tweet']\n", 603 | " data = []\n", 604 | " \n", 605 | " for tweet in tweets:\n", 606 | " data.append([tweet.user.screen_name, tweet.full_text])\n", 607 | " \n", 608 | " df = pd.DataFrame(data, columns=columns)\n", 609 | " \n", 610 | "# print(df.head())\n", 611 | "# print(\"\\n\\n\")\n", 612 | " # save user tweets to csv\n", 613 | "# print(\"LOGGER: saving user tweets to : \", USER_TWEET_DATA_FILE)\n", 614 | " df.to_csv(USER_TWEET_DATA_FILE, index=False)\n", 615 | "\n", 616 | " return df\n", 617 | "\n", 618 | "\n", 619 | "def predict_user_tweets(df):\n", 620 | " \n", 621 | " # user tweet preprocessing using NLP : nltk\n", 622 | "\n", 623 | " df['tweet'] = df['tweet'].astype(str)\n", 624 | " #remove leading and ending whitespaces\n", 625 | " df['tweet'] = df['tweet'].str.strip()\n", 626 | "\n", 627 | " # keep only alphabets\n", 628 | " df['tweet'] = df['tweet'].apply(keep_alpha)\n", 629 | "\n", 630 | " # nlp preprocessing to remove stopwords and get base/stem form of each word\n", 631 | " df['tweet'] = df['tweet'].apply(nlp_preprocessing)\n", 632 | " df['tweet'] = df['tweet'].str.strip()\n", 633 | "\n", 634 | " # replace empty rows with NAN and then drop them\n", 635 | " df['tweet'].replace('', np.nan, inplace=True)\n", 636 | " df = df.dropna()\n", 637 | " df = df.reset_index(drop=True)\n", 638 | " \n", 639 | " vectorizer = joblib.load(VECTORIZER_FILE)\n", 640 | " X_test = vectorizer.transform(df['tweet'].values )\n", 641 | " \n", 642 | " # Load/Read the model from the file at given location \"model.pkl\"\n", 643 | " # classification_model = joblib.load('model.pkl')\n", 644 | " classification_model = joblib.load(MODEL_FILE)\n", 645 | " \n", 646 | " # predicting the model on user test data\n", 647 | " y_pred=classification_model.predict(X_test)\n", 648 | " \n", 649 | "# print(y_pred)\n", 650 | " df['prediction'] = y_pred\n", 651 | " print(df[['tweet', 'prediction']])\n", 652 | " return list(y_pred)\n", 653 | "\n", 654 | "\n", 655 | "def final_output(predictions):\n", 656 | " total = len(predictions)\n", 657 | " depressed_count = predictions.count(\"YES\")\n", 658 | " \n", 659 | " print(\"\\n\\n\")\n", 660 | " \n", 661 | " if depressed_count > (total*.6):\n", 662 | " print(\"Result: DEPRESSED 😒\")\n", 663 | " else:\n", 664 | " print(\"Result: NOT DEPRESSED 😊\")\n", 665 | "\n", 666 | "user_tweets = download_user_tweets()\n", 667 | "predictions = predict_user_tweets(user_tweets)\n", 668 | "final_output(predictions)" 669 | ] 670 | } 671 | ], 672 | "metadata": { 673 | "colab": { 674 | "provenance": [] 675 | }, 676 | "kernelspec": { 677 | "display_name": "Python 3", 678 | "name": "python3" 679 | }, 680 | "language_info": { 681 | "name": "python" 682 | } 683 | }, 684 | "nbformat": 4, 685 | "nbformat_minor": 0 686 | } 687 | --------------------------------------------------------------------------------