StockPrediction_using_SVM_and_RF_hourlyComparison.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "StockPrediction_using_SVM_and_RF_hourlyComparison",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "JKRKJXUdmWNP",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 326
        },
        "outputId": "9752dc54-5f1d-42de-e078-71da905a9a2e"
      },
      "source": [
        "!pip install yfinance\n",
        "!pip install GetOldTweets3\n",
        "!pip install treeinterpreter"
      ],
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Requirement already satisfied: yfinance in /usr/local/lib/python3.6/dist-packages (0.1.54)\n",
            "Requirement already satisfied: multitasking>=0.0.7 in /usr/local/lib/python3.6/dist-packages (from yfinance) (0.0.9)\n",
            "Requirement already satisfied: numpy>=1.15 in /usr/local/lib/python3.6/dist-packages (from yfinance) (1.18.3)\n",
            "Requirement already satisfied: requests>=2.20 in /usr/local/lib/python3.6/dist-packages (from yfinance) (2.23.0)\n",
            "Requirement already satisfied: pandas>=0.24 in /usr/local/lib/python3.6/dist-packages (from yfinance) (1.0.3)\n",
            "Requirement already satisfied: chardet<4,>=3.0.2 in /usr/local/lib/python3.6/dist-packages (from requests>=2.20->yfinance) (3.0.4)\n",
            "Requirement already satisfied: idna<3,>=2.5 in /usr/local/lib/python3.6/dist-packages (from requests>=2.20->yfinance) (2.9)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.6/dist-packages (from requests>=2.20->yfinance) (2020.4.5.1)\n",
            "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in /usr/local/lib/python3.6/dist-packages (from requests>=2.20->yfinance) (1.24.3)\n",
            "Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas>=0.24->yfinance) (2018.9)\n",
            "Requirement already satisfied: python-dateutil>=2.6.1 in /usr/local/lib/python3.6/dist-packages (from pandas>=0.24->yfinance) (2.8.1)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.6/dist-packages (from python-dateutil>=2.6.1->pandas>=0.24->yfinance) (1.12.0)\n",
            "Requirement already satisfied: GetOldTweets3 in /usr/local/lib/python3.6/dist-packages (0.0.11)\n",
            "Requirement already satisfied: pyquery>=1.2.10 in /usr/local/lib/python3.6/dist-packages (from GetOldTweets3) (1.4.1)\n",
            "Requirement already satisfied: lxml>=3.5.0 in /usr/local/lib/python3.6/dist-packages (from GetOldTweets3) (4.2.6)\n",
            "Requirement already satisfied: cssselect>0.7.9 in /usr/local/lib/python3.6/dist-packages (from pyquery>=1.2.10->GetOldTweets3) (1.1.0)\n",
            "Requirement already satisfied: treeinterpreter in /usr/local/lib/python3.6/dist-packages (0.2.2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "F2DF0dVzmwmM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import datetime\n",
        "import GetOldTweets3 as got\n",
        "import yfinance as yf\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import csv\n",
        "import sys\n",
        "import re\n",
        "import string\n",
        "import json\n",
        "import os"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0_sXGERam1DV",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 153
        },
        "outputId": "88785305-4b7c-4a2d-b2a0-d78182c2340c"
      },
      "source": [
        "import nltk\n",
        "nltk.download('vader_lexicon')\n",
        "nltk.download('wordnet')\n",
        "nltk.download('stopwords')\n",
        "nltk.download('punkt')\n",
        "from nltk.corpus import stopwords\n",
        "from nltk.tokenize import word_tokenize\n",
        "\n",
        "from nltk.sentiment import SentimentAnalyzer\n",
        "from nltk.sentiment.vader import SentimentIntensityAnalyzer\n",
        "import unicodedata\n",
        "sentiment_i_a = SentimentIntensityAnalyzer()\n",
        "\n",
        "from nltk.corpus import subjectivity\n",
        "from nltk.sentiment.util import *"
      ],
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[nltk_data] Downloading package vader_lexicon to /root/nltk_data...\n",
            "[nltk_data]   Package vader_lexicon is already up-to-date!\n",
            "[nltk_data] Downloading package wordnet to /root/nltk_data...\n",
            "[nltk_data]   Package wordnet is already up-to-date!\n",
            "[nltk_data] Downloading package stopwords to /root/nltk_data...\n",
            "[nltk_data]   Package stopwords is already up-to-date!\n",
            "[nltk_data] Downloading package punkt to /root/nltk_data...\n",
            "[nltk_data]   Package punkt is already up-to-date!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mGKnfF23m3rr",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from treeinterpreter import treeinterpreter as ti\n",
        "from sklearn.tree import DecisionTreeRegressor\n",
        "from sklearn.ensemble import RandomForestRegressor\n",
        "\n",
        "from sklearn import svm\n",
        "from sklearn.svm import SVR \n",
        "\n",
        "from sklearn.metrics import mean_squared_error\n",
        "from math import sqrt\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "L3yLYfHtm9oa",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Get hourly stock data\n",
        "def getHourlyStocks(stockname):\n",
        "  company = yf.Ticker(stockname)\n",
        "  stockdata = company.history(interval=\"60m\")\n",
        "  stockdata.to_csv('stockData_' + stockname +'.csv')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7PMf1VAUY8DM",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# process stock data to get date and time separately\n",
        "def processStockData(stockname):\n",
        "  stockdata = pd.read_csv('stockData_' + stockname +'.csv',encoding='utf-8')\n",
        "  stockdata.head()\n",
        "\n",
        "  temp = str(stockdata['Datetime'].values)\n",
        "  new = temp.split(\"\\n\")\n",
        "  temp1 = ' '.join(str(new).split())\n",
        "  temp1 = temp1.replace('\"', '')\n",
        "  temp1 = temp1.replace('\\'', '')\n",
        "  temp1 = temp1.replace(',', '')\n",
        "  temp1 = temp1.replace('[', '')\n",
        "  temp1 = temp1.replace(']', '')\n",
        "  temp1 = temp1.replace('-04:00', '')\n",
        "  new2 = temp1.split(\" \")\n",
        "  new2 = [x.strip() for x in new2 if x.strip()]\n",
        "\n",
        "  indx = 0\n",
        "  for i in range(0,len(new2),2):\n",
        "    stockdata.at[indx,'date'] = new2[i]\n",
        "    indx = indx + 1\n",
        "\n",
        "  indx = 0\n",
        "  for j in range(1,len(new2),2):\n",
        "    stockdata.at[indx,'time'] = new2[j]\n",
        "    indx = indx + 1\n",
        "\n",
        "  stockdata = stockdata.drop('Datetime', 1)\n",
        "  stockdata['time'] = stockdata['time'].apply(lambda x: datetime.datetime.strptime(x,'%H:%M:%S').time())\n",
        "  stockdata.head()\n",
        "  stockdata.to_csv('processedStockData_' + stockname +'.csv')\n",
        "  startDate = stockdata['date'].iloc[0]\n",
        "  endDate = stockdata['date'].iloc[len(stockdata)-1]\n",
        "  return startDate, endDate"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Za9kkTJWoBDs",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#Method for data cleaning\n",
        "class TweetCleaner:\n",
        "    def __init__(self):\n",
        "        self.stop_words = set(stopwords.words('english'))\n",
        "        self.punc_table = str.maketrans(\"\", \"\", string.punctuation) # to remove punctuation from each word in tokenize\n",
        "\n",
        "    def compound_word_split(self, compound_word):\n",
        "        matches = re.finditer('.+?(?:(?<=[a-z])(?=[A-Z])|(?<=[A-Z])(?=[A-Z][a-z])|$)', compound_word)\n",
        "        return [m.group(0) for m in matches]\n",
        "\n",
        "    def remove_non_ascii_chars(self, text):\n",
        "        return ''.join([w if ord(w) < 128 else ' ' for w in text])\n",
        "\n",
        "    def remove_hyperlinks(self,text):\n",
        "        return ' '.join([w for w in text.split(' ')  if not 'http' in w])\n",
        "\n",
        "    def get_cleaned_text(self, text):\n",
        "        cleaned_tweet = text.replace('\\\"','').replace('\\'','').replace('-',' ')\n",
        "        cleaned_tweet =  self.remove_non_ascii_chars(cleaned_tweet)\n",
        "        if re.match(r'RT @[_A-Za-z0-9]+:',cleaned_tweet):\n",
        "            cleaned_tweet = cleaned_tweet[cleaned_tweet.index(':')+2:]\n",
        "        cleaned_tweet = self.remove_hyperlinks(cleaned_tweet)\n",
        "        cleaned_tweet = cleaned_tweet.replace('#','HASHTAGSYMBOL').replace('@','ATSYMBOL') # to avoid being removed while removing punctuations\n",
        "        tokens = [w.translate(self.punc_table) for w in word_tokenize(cleaned_tweet)] # remove punctuations and tokenize\n",
        "        tokens = [nltk.WordNetLemmatizer().lemmatize(w) for w in tokens if not w.lower() in self.stop_words and len(w)>1] # remove stopwords and single length words\n",
        "        cleaned_tweet = ' '.join(tokens)\n",
        "        cleaned_tweet = cleaned_tweet.replace('HASHTAGSYMBOL','#').replace('ATSYMBOL','@')\n",
        "        cleaned_tweet = cleaned_tweet\n",
        "        return cleaned_tweet\n",
        "\n",
        "    def clean_tweets(self, tweets, is_bytes = False):   \n",
        "        test_tweet_list = []\n",
        "        for tweet in tweets:\n",
        "            if is_bytes:\n",
        "                test_tweet_list.append(self.get_cleaned_text(ast.literal_eval(tweet).decode(\"UTF-8\")))\n",
        "            else:\n",
        "                test_tweet_list.append(self.get_cleaned_text(tweet))\n",
        "        return test_tweet_list\n",
        "    \n",
        "    def clean_single_tweet(self, tweet, is_bytes = False):  \n",
        "        if is_bytes:\n",
        "             return self.get_cleaned_text(ast.literal_eval(tweet).decode(\"UTF-8\"))\n",
        "        return self.get_cleaned_text(tweet)\n",
        "    \n",
        "    def cleaned_file_creator(self, op_file_name, value1, value2):\n",
        "        csvFile = open(op_file_name, 'w+')\n",
        "        csvWriter = csv.writer(csvFile)\n",
        "        for tweet in range(len(value1)):\n",
        "            csvWriter.writerow([value1[tweet], value2[tweet]])\n",
        "        csvFile.close()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eI38W6S8oR1g",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "#fetch tweet data\n",
        "def fetchTweets(stockname, startDate, endDate):\n",
        "  csvFile = open('tweets_' + stockname + '.csv', 'a',encoding=\"utf-8\")\n",
        "  csvWriter = csv.writer(csvFile, lineterminator= '\\n')\n",
        "  cleanObj = TweetCleaner()\n",
        "  \n",
        "  tweetCriteria = got.manager.TweetCriteria().setQuerySearch(stockname).setSince(startDate).setUntil(endDate).setTopTweets(\"true\") \n",
        "  tweets = got.manager.TweetManager.getTweets(tweetCriteria)\n",
        "  try:\n",
        "    for tweet in tweets:\n",
        "      tweet_text = tweet.text.encode('utf-8')\n",
        "      tweet_text = cleanObj.get_cleaned_text(tweet_text.decode())\n",
        "      tweetDate = tweet.date\n",
        "      csvWriter.writerow([tweetDate, tweet.text])\n",
        "  except BaseException as e:\n",
        "      print('failed on_status,',str(e))\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BQVAESXMoosz",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# process tweet data to get date and time separately\n",
        "def processTweetData(stockname):\n",
        "  columns=['Date','Tweets']\n",
        "  tweets = pd.read_csv('tweets_' + stockname + '.csv',encoding='utf-8', names=columns, header=None)\n",
        "\n",
        "  temp = str(tweets['Date'].values)\n",
        "  new = temp.split(\"\\n\")\n",
        "  temp1 = ' '.join(str(new).split())\n",
        "  temp1 = temp1.replace('\"', '')\n",
        "  temp1 = temp1.replace('\\'', '')\n",
        "  temp1 = temp1.replace(',', '')\n",
        "  temp1 = temp1.replace('[', '')\n",
        "  temp1 = temp1.replace(']', '')\n",
        "  temp1 = temp1.replace('+00:00', '')\n",
        "  new2 = temp1.split(\" \")\n",
        "  new2 = [x.strip() for x in new2 if x.strip()]\n",
        "\n",
        "  indx = 0\n",
        "  for i in range(0,len(new2),2):\n",
        "    tweets.at[indx,'date'] = new2[i]\n",
        "    indx = indx + 1\n",
        "\n",
        "  indx = 0\n",
        "  for j in range(1,len(new2),2):\n",
        "    tweets.at[indx,'time'] = new2[j]\n",
        "    indx = indx + 1\n",
        "\n",
        "  tweets = tweets.drop('Date', 1)\n",
        "  tweets.head()\n",
        "  tweets.to_csv('processedTweets_' + stockname + '.csv')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Bs0qj0hvvAgQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# process both stock and tweet data to get prices for respective date and time\n",
        "def processData(stockname):\n",
        "  date_time_obj1 = datetime.datetime.strptime('09:30:00', '%H:%M:%S').time()\n",
        "  date_time_obj2 = datetime.datetime.strptime('10:30:00', '%H:%M:%S').time()\n",
        "  date_time_obj3 = datetime.datetime.strptime('11:30:00', '%H:%M:%S').time()\n",
        "  date_time_obj4 = datetime.datetime.strptime('12:30:00', '%H:%M:%S').time()\n",
        "  date_time_obj5 = datetime.datetime.strptime('13:30:00', '%H:%M:%S').time()\n",
        "  date_time_obj6 = datetime.datetime.strptime('14:30:00', '%H:%M:%S').time()\n",
        "  date_time_obj7 = datetime.datetime.strptime('15:30:00', '%H:%M:%S').time()\n",
        "\n",
        "  column_names = [\"date\", \"time\", \"Tweets\"]\n",
        "  df = pd.DataFrame(columns = column_names)\n",
        "\n",
        "  tweets = pd.read_csv('processedTweets_' + stockname + '.csv',encoding='utf-8')\n",
        "  tweets['time'] = tweets['time'].apply(lambda x: datetime.datetime.strptime(x,'%H:%M:%S').time())\n",
        "  \n",
        "  readStockData = pd.read_csv('processedStockData_' + stockname +'.csv')\n",
        "\n",
        "  indx1 = 0 \n",
        "  indx2 = 1\n",
        "  indx3 = 2 \n",
        "  indx4 = 3\n",
        "  indx5 = 4 \n",
        "  indx6 = 5\n",
        "\n",
        "  get_tweet1 = \"\"\n",
        "  get_tweet2 = \"\"\n",
        "  get_tweet3 = \"\"\n",
        "  get_tweet4 = \"\"\n",
        "  get_tweet5 = \"\"\n",
        "  get_tweet6 = \"\"\n",
        "\n",
        "  # mapping hourly tweets\n",
        "  for i in range(0,len(tweets)-1):\n",
        "    get_date= tweets.date.iloc[i]\n",
        "    next_date= tweets.date.iloc[i+1]\n",
        "    if(str(get_date)==str(next_date)):\n",
        "      # check time\n",
        "      if tweets.time.iloc[i] > date_time_obj1 and tweets.time.iloc[i] < date_time_obj2:\n",
        "        get_tweet1 = get_tweet1 + tweets.Tweets.iloc[i] + \" \"\n",
        "\n",
        "      if tweets.time.iloc[i] > date_time_obj2 and tweets.time.iloc[i] < date_time_obj3:\n",
        "        get_tweet2 = get_tweet2 + tweets.Tweets.iloc[i] + \" \"\n",
        "\n",
        "      if tweets.time.iloc[i] > date_time_obj3 and tweets.time.iloc[i] < date_time_obj4:\n",
        "        get_tweet3 = get_tweet3 + tweets.Tweets.iloc[i] + \" \"\n",
        "\n",
        "      if tweets.time.iloc[i] > date_time_obj4 and tweets.time.iloc[i] < date_time_obj5:\n",
        "        get_tweet4 = get_tweet4 + tweets.Tweets.iloc[i] + \" \"\n",
        "\n",
        "      if tweets.time.iloc[i] > date_time_obj5 and tweets.time.iloc[i] < date_time_obj6:\n",
        "        get_tweet5 = get_tweet5 + tweets.Tweets.iloc[i] + \" \"\n",
        "\n",
        "      if tweets.time.iloc[i] > date_time_obj6 and tweets.time.iloc[i] < date_time_obj7:\n",
        "        get_tweet6 = get_tweet6 + tweets.Tweets.iloc[i] + \" \"\n",
        "    \n",
        "    if(str(get_date)!=str(next_date)):\n",
        "      df.at[indx1,'date'] = get_date\n",
        "      df.at[indx1,'time'] = date_time_obj2\n",
        "      df.at[indx1,'Tweets'] = get_tweet1\n",
        "\n",
        "      df.at[indx2,'date'] = get_date\n",
        "      df.at[indx2,'time'] = date_time_obj3\n",
        "      df.at[indx2,'Tweets'] = get_tweet2\n",
        "\n",
        "      df.at[indx3,'date'] = get_date\n",
        "      df.at[indx3,'time'] = date_time_obj4\n",
        "      df.at[indx3,'Tweets'] = get_tweet3\n",
        "\n",
        "      df.at[indx4,'date'] = get_date\n",
        "      df.at[indx4,'time'] = date_time_obj5\n",
        "      df.at[indx4,'Tweets'] = get_tweet4\n",
        "\n",
        "      df.at[indx5,'date'] = get_date\n",
        "      df.at[indx5,'time'] = date_time_obj6\n",
        "      df.at[indx5,'Tweets'] = get_tweet5\n",
        "\n",
        "      df.at[indx6,'date'] = get_date\n",
        "      df.at[indx6,'time'] = date_time_obj7\n",
        "      df.at[indx6,'Tweets'] = get_tweet6\n",
        "\n",
        "      indx1 = indx1 + 6\n",
        "      indx2 = indx2 + 6\n",
        "      indx3 = indx3 + 6\n",
        "      indx4 = indx4 + 6\n",
        "      indx5 = indx5 + 6\n",
        "      indx6 = indx6 + 6\n",
        "\n",
        "      get_tweet1 = \"\"\n",
        "      get_tweet2 = \"\"\n",
        "      get_tweet3 = \"\"\n",
        "      get_tweet4 = \"\"\n",
        "      get_tweet5 = \"\"\n",
        "      get_tweet6 = \"\"\n",
        "\n",
        "  # drop rows if tweets are not present\n",
        "  df['Tweets'].replace('', np.nan, inplace=True)\n",
        "  df.dropna(subset=['Tweets'], inplace=True)\n",
        "  df.reset_index(drop=True, inplace=True)\n",
        "  df.head()\n",
        "\n",
        "  # map prices for respective date and time\n",
        "  df['Prices']=\"\"\n",
        "  for i in range (0,len(df)):\n",
        "    for j in range (0,len(readStockData)):\n",
        "      get_tweet_date = df.date.iloc[i]\n",
        "      get_tweet_time = df.time.iloc[i]\n",
        "\n",
        "      get_stock_date = readStockData.date.iloc[j]\n",
        "      get_stock_time = readStockData.time.iloc[j]\n",
        "\n",
        "      if(str(get_stock_date)==str(get_tweet_date)):\n",
        "        if(str(get_tweet_time) == str(get_stock_time)):\n",
        "          df.at[i,'Prices'] = int(readStockData.Close[j])\n",
        "          break\n",
        "\n",
        "  # dropping rows if prices are not available\n",
        "  df['Prices'].replace('', np.nan, inplace=True)\n",
        "  df.dropna(subset=['Prices'], inplace=True)\n",
        "  df.reset_index(drop=True, inplace=True)\n",
        "  df['Prices'] = df['Prices'].apply(np.int64)        \n",
        "  df.to_csv('processedData_' + stockname +'.csv')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0z9KD24fvLuZ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# performing sentiment analysis\n",
        "def sentimentAnalysis(stockname):\n",
        "  df = pd.read_csv('processedData_' + stockname +'.csv')\n",
        "  df[\"Comp\"] = ''\n",
        "  df[\"Negative\"] = ''\n",
        "  df[\"Neutral\"] = ''\n",
        "  df[\"Positive\"] = ''\n",
        "  for indexx, row in df.T.iteritems():\n",
        "    try:\n",
        "      sentence_i = unicodedata.normalize('NFKD', df.loc[indexx, 'Tweets'])\n",
        "      sentence_sentiment = sentiment_i_a.polarity_scores(sentence_i)\n",
        "      df.at[indexx, 'Comp'] =  sentence_sentiment['compound']\n",
        "      df.at[indexx, 'Negative'] = sentence_sentiment['neg']\n",
        "      df.at[indexx, 'Neutral'] =  sentence_sentiment['neu']\n",
        "      df.at[indexx, 'Positive'] = sentence_sentiment['pos'] \n",
        "    except TypeError:\n",
        "      print('failed on_status,',str(e))\n",
        "\n",
        "  print(df.head())\n",
        "  df.to_csv('sentimentAnalysis_' + stockname +'.csv')\n",
        "  posi=0\n",
        "  nega=0\n",
        "  neutral = 0\n",
        "  for i in range (0,len(df)):\n",
        "    get_val=df.Comp[i]\n",
        "    if(float(get_val)<(0)):\n",
        "        nega=nega+1\n",
        "    if(float(get_val>(0))):\n",
        "        posi=posi+1\n",
        "    if(float(get_val)==(0)):\n",
        "        neutral=neutral+1\n",
        "\n",
        "  posper=(posi/(len(df)))*100\n",
        "  negper=(nega/(len(df)))*100\n",
        "  neutralper=(neutral/(len(df)))*100\n",
        "\n",
        "  print(\"% of positive tweets= \",posper)\n",
        "  print(\"% of negative tweets= \",negper)\n",
        "  print(\"% of neutral tweets= \",neutralper)\n",
        "\n",
        "  arr=np.asarray([posper,negper,neutralper], dtype=int)\n",
        "  plt.figure()\n",
        "  plt.pie(arr,labels=['positive','negative', 'neutral'])\n",
        "  plt.plot()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BQjF3yOovSKI",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Predicting stock prices using Random Forest model\n",
        "def RandomForestModel(stockname):\n",
        "  df = pd.read_csv('sentimentAnalysis_' + stockname +'.csv')\n",
        "  train, test = train_test_split(df, shuffle=False, test_size=0.2)\n",
        "  print(train.size)\n",
        "  print(test.size)\n",
        "\n",
        "  sentiment_score_list_train = []\n",
        "  for date, row in train.T.iteritems():\n",
        "    sentiment_score = np.asarray([df.loc[date, 'Negative'], df.loc[date, 'Neutral'],  df.loc[date, 'Positive']])\n",
        "    sentiment_score_list_train.append(sentiment_score)\n",
        "  numpy_df_train = np.asarray(sentiment_score_list_train)\n",
        "\n",
        "  sentiment_score_list_test = []\n",
        "  for date, row in test.T.iteritems():\n",
        "    sentiment_score = np.asarray([df.loc[date, 'Negative'], df.loc[date, 'Neutral'], df.loc[date, 'Positive']])\n",
        "    sentiment_score_list_test.append(sentiment_score)\n",
        "  numpy_df_test = np.asarray(sentiment_score_list_test)\n",
        "\n",
        "  y_train = pd.DataFrame(train['Prices'])\n",
        "  y_test = pd.DataFrame(test['Prices'])\n",
        "\n",
        "  rf = RandomForestRegressor()\n",
        "  rf.fit(numpy_df_train, y_train)\n",
        "  prediction, bias, contributions = ti.predict(rf, numpy_df_test)\n",
        "\n",
        "  print(\"\\n\\n\")\n",
        "  plt.figure()\n",
        "  plt.plot(test['Prices'].iloc[:].values)\n",
        "  plt.plot(prediction.flatten())\n",
        "  plt.title('Random Forest predicted prices')\n",
        "  plt.ylabel('Stock Prices')\n",
        "  plt.xlabel('Days')\n",
        "  plt.legend(['actual', 'predicted'])\n",
        "  plt.show()\n",
        "\n",
        "  print(\"\\n\\n\")\n",
        "  print(\"RMSE value for Random Forest Model : \")\n",
        "  rmse = sqrt(mean_squared_error(y_test, prediction.flatten()))\n",
        "  print(rmse)\n",
        "  print(\"\\n\\n\")\n"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "t1rjsOY6vaNQ",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Predicting stock prices using Support Vector Regression model\n",
        "def SVRModel(stockname):\n",
        "  df = pd.read_csv('sentimentAnalysis_' + stockname +'.csv')\n",
        "  train, test = train_test_split(df, shuffle=False, test_size=0.2)\n",
        "  print(train.size)\n",
        "  print(test.size)\n",
        "\n",
        "  sentiment_score_list_train = []\n",
        "  for date, row in train.T.iteritems():\n",
        "    sentiment_score = np.asarray([df.loc[date, 'Negative'], df.loc[date, 'Neutral'],  df.loc[date, 'Positive']])\n",
        "    sentiment_score_list_train.append(sentiment_score)\n",
        "  numpy_df_train = np.asarray(sentiment_score_list_train)\n",
        "\n",
        "  sentiment_score_list_test = []\n",
        "  for date, row in test.T.iteritems():\n",
        "    sentiment_score = np.asarray([df.loc[date, 'Negative'], df.loc[date, 'Neutral'], df.loc[date, 'Positive']])\n",
        "    sentiment_score_list_test.append(sentiment_score)\n",
        "  numpy_df_test = np.asarray(sentiment_score_list_test)\n",
        "\n",
        "  y_train = pd.DataFrame(train['Prices'])\n",
        "  y_test = pd.DataFrame(test['Prices'])\n",
        "\n",
        "  svr_rbf = SVR(kernel='rbf', C=1e6, gamma=0.1)\n",
        "  svr_rbf.fit(numpy_df_train, y_train.values.flatten())\n",
        "  output_test_svm = svr_rbf.predict(numpy_df_test)\n",
        "\n",
        "  plt.figure()\n",
        "  plt.plot(test['Prices'].iloc[:].values)\n",
        "  plt.plot(output_test_svm)\n",
        "  plt.title('SVM predicted prices')\n",
        "  plt.ylabel('Stock Prices')\n",
        "  plt.xlabel('Days')\n",
        "  plt.legend(['actual', 'predicted'])\n",
        "  plt.show()\n",
        "\n",
        "  print(\"\\n\\n\")\n",
        "  print(\"RMSE value for Support Vector Regression Model : \")\n",
        "  rmse = sqrt(mean_squared_error(y_test, output_test_svm))\n",
        "  print(rmse)\n",
        "  print(\"\\n\\n\")"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lZ_mXvB1WiUp",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "08b7b60e-8dc9-441b-f274-3ee4fb1ee8c1"
      },
      "source": [
        "def main():\n",
        "  name = input(\"Enter a valid STOCKNAME of the Corporation: \") #enter the name of the company\n",
        "  if(len(name) > 0):\n",
        "    STOCKNAME  = name\n",
        "  else:\n",
        "    STOCKNAME = \"AAPL\"\n",
        "\n",
        "  #Get Stock Details and get date and time\n",
        "  print(\"------------------------------ Getting Stock details and processing it -----------------------------\")\n",
        "  getHourlyStocks(STOCKNAME)\n",
        "  startDate, endDate = processStockData(STOCKNAME)\n",
        "  print(\"Stock Details fetched! \\n\")\n",
        "\n",
        "  #Fetching tweets and get date and time\n",
        "  print(\"------------------------------ Fetching Tweets and processing it-----------------------------\")\n",
        "  fetchTweets(STOCKNAME, startDate, endDate)\n",
        "  processTweetData(STOCKNAME)\n",
        "  print(\"Tweets fetched! \\n\")\n",
        "\n",
        "  # Process data by fetching Tweets and prices for respective date and hour\n",
        "  print(\"------------- Process data by fetching Tweets and prices for respective date and hour ----------------------\")\n",
        "  processData(STOCKNAME)\n",
        "  print(\"Completed Data Processing! \\n\")\n",
        "\n",
        "  # Sentiment analysis of tweets on hourly basis\n",
        "  print(\"------------------------------ Sentiment analysis of tweets on hourly basis-----------------------------\")\n",
        "  sentimentAnalysis(STOCKNAME)\n",
        "  print(\"Completed sentiment Analysis! \\n\")\n",
        "\n",
        "  # Predicting stock prices using Random Forest model\n",
        "  print(\"------------------------------ Predicting stock prices using Random Forest model-----------------------------\")\n",
        "  RandomForestModel(STOCKNAME)\n",
        "  print(\"Completed Random Forest prediction! \\n\")\n",
        "\n",
        "  # Predicting stock prices using Support Vector Regression model\n",
        "  print(\"------------------------------ Predicting stock prices using Support Vector Regression model-----------------------------\")\n",
        "  SVRModel(STOCKNAME)\n",
        "  print(\"Completed Support Vector Regression prediction! \\n\")\n",
        "\n",
        "main()"
      ],
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter a valid STOCKNAME of the Corporation: \n",
            "------------------------------ Getting Stock details and processing it -----------------------------\n",
            "Stock Details fetched! \n",
            "\n",
            "------------------------------ Fetching Tweets and processing it-----------------------------\n",
            "Tweets fetched! \n",
            "\n",
            "------------- Process data by fetching Tweets and prices for respective date and hour ----------------------\n",
            "Completed Data Processing! \n",
            "\n",
            "------------------------------ Sentiment analysis of tweets on hourly basis-----------------------------\n",
            "   Unnamed: 0        date      time  ... Negative  Neutral Positive\n",
            "0           0  2020-04-30  14:30:00  ...        0        1        0\n",
            "1           1  2020-04-29  15:30:00  ...        0        1        0\n",
            "2           2  2020-04-30  11:30:00  ...        0        1        0\n",
            "3           3  2020-04-30  14:30:00  ...    0.159     0.53    0.311\n",
            "4           4  2020-04-27  14:30:00  ...        0    0.838    0.162\n",
            "\n",
            "[5 rows x 9 columns]\n",
            "% of positive tweets=  43.54838709677419\n",
            "% of negative tweets=  25.806451612903224\n",
            "% of neutral tweets=  30.64516129032258\n",
            "Completed sentiment Analysis! \n",
            "\n",
            "------------------------------ Predicting stock prices using Random Forest model-----------------------------\n",
            "490\n",
            "130\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:23: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples,), for example using ravel().\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "\n",
            "RMSE value for Random Forest Model : \n",
            "28.70300286235729\n",
            "\n",
            "\n",
            "\n",
            "Completed Random Forest prediction! \n",
            "\n",
            "------------------------------ Predicting stock prices using Support Vector Regression model-----------------------------\n",
            "490\n",
            "130\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "text": [
            "\n",
            "\n",
            "\n",
            "RMSE value for Support Vector Regression Model : \n",
            "29.510346059426293\n",
            "\n",
            "\n",
            "\n",
            "Completed Support Vector Regression prediction! \n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0SL2wDy9cqoy",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}