Wall Street Bets Sentiment Analysis 12/01 - 12/12/2020

By: Mahi Mulpuri and Yueshan Wang

Objectives:

1. Scrape Reddit data from Wall Street Bets, a subreddit on Reddit, to aggregate general market sentiment about stocks
2. Visualize scraped data to gain understanding about certain stocks and future trends within market
3. Perform some basic ML to shed some light about what might be good 'due diligence' on stocks, and what good due diligence might look like

Motivation

The main motivation for this project lies behind gaining some intuition on what general consensus among novice traders might be. One might say this is a fruitless principle as novice traders often make very little reasonable trades based on classic trading princples, however some hedge funds such as Citadel might say otherwise. Over the past few years Citadel has entered into a contract allowing them the sole ability to buy data from Robinhood a trading platform used mostly by novice traders and most of the people on Wall Street Bets. The idea is that data on what novice traders might be doing in the right hands can be very worthwhile in determining good systematic trading strategies. For example, in the project we will show a lot of interest in the stock PLTR within this time period that has very high volatility and a large margin for algo traders to make off of it.

Scraping Data

In the following two cells we will scrape data from a number of 'daily discussion posts' on Wall Street Bets and put this data into a dataframe for visualization later on. We will collect comments, users, time stamps, karma, and lastly interaction via replies.

We will use Python 3 as well as some pandas, numpy, matplotlib, seaborn, praw, scikit-learn and math and datetime to handle data from reddit

import praw
import re
import pandas as pd
import datetime
import math
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn import model_selection
from sklearn import linear_model
from sklearn import preprocessing
import numpy as np

reddit = praw.Reddit(
    client_id="DxS7Nu00NAKTzA",
    client_secret="nrSj-VrF5j7YiGMfftFAYTO6eMXOvw",
    user_agent="school project"
)

posts = ['k4ixya','k57d6a','k5vaj4','k6j06n','k6tl0d','k8el96','k92ab0','k9pwht','kadem4','kb0pf8','kbb812']
all_posts1 = []
for post in posts:
    print("loading post " + post)
    i = 1
    submission = reddit.submission(id = post)
    submission.comment_sort = "top"
    submission.comments.replace_more(limit=2)
    for comment in submission.comments.list():
       
        try:
        
            all_posts1.append([comment.author, comment.author.comment_karma, datetime.datetime.fromtimestamp(comment.created_utc), comment.body, comment.score, comment.distinguished, len(comment.replies), i, post, comment.body])
       
        except Exception:
            all_posts1.append(['deleted', 'deleted',datetime.datetime.fromtimestamp(comment.created_utc),comment.body, comment.score,comment.distinguished,len(comment.replies),i,post, comment.body])
            
        i = i + 1
wsb2 = pd.DataFrame(all_posts1,columns=['redditor', 'karma','time' ,'comment','upvotes','gilded','interaction','rank','post_id', 'tickers'])
wsb2.head()

loading post k4ixya
loading post k57d6a
loading post k5vaj4
loading post k6j06n
loading post k6tl0d
loading post k8el96
loading post k92ab0
loading post k9pwht
loading post kadem4
loading post kb0pf8
loading post kbb812

	redditor	karma	time	comment	upvotes	gilded	interaction	rank	post_id	tickers
0	EatMaTesticles	11187	2020-12-01 06:50:02	Can you imagine SEC officials reading this sub...	316	None	2	1	k4ixya	Can you imagine SEC officials reading this sub...
1	AFruitShopOwner	46665	2020-12-01 06:13:37	I'm over-leveraged and underinformed 🚀	240	None	1	2	k4ixya	I'm over-leveraged and underinformed 🚀
2	TOADSTOOL__SURPRISE	92737	2020-12-01 06:33:41	I was in the club last night scrolling through...	195	None	1	3	k4ixya	I was in the club last night scrolling through...
3	Catheter_Trader	2509	2020-12-01 06:18:33	#STONKS GO UP FUCK YOUR PUTS	153	None	1	4	k4ixya	#STONKS GO UP FUCK YOUR PUTS
4	MorpheusOnAcid	9916	2020-12-01 07:36:26	Atleast at the casino there's cool flashing li...	154	None	1	5	k4ixya	Atleast at the casino there's cool flashing li...

Need to pip install get_all_tickers to grab stock ticker symbols

click here to read more about get_all_tickers

When the data from reddit is first added to our data frame the "comment" column and "tickers" column are the same. Before we match tickers in comments with stocks we need to import a list of stocks using get_all_tickers. We use the get_all_tickers_filtered function with a minimum market cap of \$1 billion in order to only get companies with a greater market cap than \\$1 billion.

We have also created a short list of common words that should be excluded from our list of tickers such as "ARE" and "HAS".

We will preprocess this data from reddit by cross checking any words in the comment with stock tickers using our list of tickers we imported. We use a regex that matches any 2-5 character word whose first character is capitalized.

# Cross check valid stock ticker symbols mentions from list
from get_all_tickers import get_tickers as gt
list_of_tickers = gt.get_tickers_filtered(mktcap_min = 1000)
lookup = set(list_of_tickers)

common_words = ["HAS","MAN", "BRO", "ARE", "SO", "IT", "GO", "HE", "SHE", "OUT", "HOPE", "NOV", "AIR", "ON", "OR", "ALL", "NOW"]

wsb = wsb2.copy(deep = True)
for index, row in wsb.iterrows():
    reg_tickers = re.findall(r'[$][A-Z][\S]*', row['tickers'])
    reg_tickers = [e[1:] for e in reg_tickers]
    other_tickers =  re.findall(r'\b[A-Z][a-zA-Z]{1,4}\b', row['tickers'])
    all_tick = reg_tickers + other_tickers
    final = []
    for tick in all_tick:
        if tick.upper() in lookup and tick.upper() not in common_words:
            final.append(tick.upper())
    wsb.at[index, 'tickers'] = final
    

Visualizing Data

In the following cells we will be taking a look at what users on Wall Street Bets are most interested in. Also we will be running a few regressions on the most interested stocks! From this information we can draw some ideas on what stocks we should be making plays on.

#for index, row in wsb.iterrows():
   # wsb.at[index,'time']  = row['time']

freq = {}
for index, row in wsb.iterrows():
    for tick in row['tickers']:
        if tick in freq:
            freq[tick] = freq[tick] + 1
        else:
            freq[tick] = 1
freq_df = pd.DataFrame(freq.items(), columns=['Stock', 'Mentions'])

In this simple graph, we can see the stocks with the most buzz around them are as follows for this time period: PLTR, TSLA, GME, NIO, ABNB, RH. We will be focussing on the first 5 for the rest our analysis!

freq_df = freq_df.sort_values(by=['Mentions'], ascending = False)
freq_df = freq_df.head(40)
freq_df.plot(kind='bar', x = "Stock", title = "Stock vs Mentions", figsize=(22,12))

<AxesSubplot:title={'center':'Stock vs Mentions'}, xlabel='Stock'>

PLTR dominates the discussion with a total mention count that is greater than the next 4 stocks combined!

fetch_stocks = freq_df['Stock'].to_list()

Need to pip install yfinance

import yfinance as yf
data = yf.download(fetch_stocks, start="2020-12-01", end="2020-12-20")

[*********************100%***********************]  40 of 40 completed

In the following cells, we plot sentiment overtime against the price of the stock over time. We can establish some pretty strong correlation visually between the movement of a stock and interest in it. We can see that overtime as a stock is increasing in price interest usually seems to pick up as it peaks around the 'bull flag' and tapers off as the price of the stock also falls. This type of data can be used to understand rudimentary trades about some stocks. A basic idea is that volatility is sure to follow stocks that sentiment increases from our sample set.

def aggregate_interest(s):
    stock_time = {}
    for index, row in wsb.iterrows():
        if s in row['tickers']:
            date = str(row['time'].date())
            if date in stock_time:
                stock_time[date] = stock_time[date] + 1
            else:
                stock_time[date] = 1
    df = data.filter([('Adj Close', s),('Close', s),('High', s),('Low', s),('Open', s),('Volume', s)], axis=1)
    toAppend = []
    for i, row in df.iterrows():
        if str(i.date()) in stock_time:
            toAppend.append(stock_time[str(i.date())])
        else:
            toAppend.append(0)
    df['interest'] = toAppend
    plt.figure(figsize=(20,12))
    f1 = sns.lineplot(data=df["Close"])
    f1.set(title=s + ' Closing Price vs Time')
    plt.figure(figsize=(20,12))
    f2 = sns.lineplot(data=df["interest"])
    f2.set(title=s + ' Interest vs Time')
   
    res1 = f1.get_figure()
    res2 = f2.get_figure()
    return (res1,res2)

# top 5 interest
for i in range(0, 5):
    (res1, res2) = aggregate_interest(fetch_stocks[i])

In the following cells we take a look at general sentiment among the users of wall street bets. The way we define the upward vector of sentiment is that comments mentioning a 'call' signify long(or short) term belief that the stock they are referring to will rise in price, whereas 'put' refers to a stock they believe will drop in the short or long term depending on their strike date. Moreover, notice how bear is actually used in our upward calculation, interestingly enough comments mentioning a bear actually appear to signify that the user hold the opposite belief that the market is going up and that bears are wrong, and vice versa for bulls. From the general sentiment graph we can see that around the middle of our time period 12/05 - 12/07 is when the market was filled with the most opposing opinions as our vector neared 0. Leading up to this point and following it we can assume that the market was short, then long respectively.

# general market sentiment using LFs
calls_up = []
puts_down = []
for i, row in wsb.iterrows():
    search = row['comment'].upper()
    if 'CALL' in search or 'CALLS' in search or 'BOUGHT' in search or 'UP' in search or 'LONG' in search or 'BEAR' in search or 'BEARS' in search:
        calls_up.append(1)
    else:
        calls_up.append(0)
    if "PUT" in search or "PUTS" in search or "SOLD" in search or "DOWN" in search or "SHORT" in search or "BULL" in search or 'BULLS' in search:
        puts_down.append(1)
    else:
        puts_down.append(0)

wsb['upwards'] = calls_up
wsb['downwards'] = puts_down

overall_trend = {}
for i, row in wsb.iterrows():
    lookup = str(row['time'].date())
    if lookup in overall_trend:
        overall_trend[lookup] = overall_trend[lookup] + (row['upwards'] - row['downwards'])
    else:
        overall_trend[lookup] = (row['upwards'] - row['downwards'])
    
dates = list(overall_trend.keys())
vals = list(overall_trend.values())
plt.figure(figsize=(20,12))

plt.plot_date(dates, vals, '-')
plt.title("General Sentiment")

Text(0.5, 1.0, 'General Sentiment')

From this we can see that the market is generally more bullish in the eyes of those at wall street bets and calls dominate the mentions of puts overall.

# Analyze puts v calls


calls= []
puts=[]
for i, row in wsb.iterrows():
    search = row['comment'].upper()
    if "CALL" in search or "CALLS" in search:
        calls.append(1)
    else:
         calls.append(0)
    if "PUT" in search or "PUTS" in search:
        puts.append(1)
    else:
        puts.append(0)
wsb['call?'] = calls
wsb['put?'] = puts
calls_d = {}
puts_d = {}
for i, row in wsb.iterrows():
    lookup = str(row['time'].date())
    if lookup in calls_d:
        calls_d[lookup] = calls_d[lookup] + row['call?']
        puts_d[lookup] = puts_d[lookup] + row['put?']
    else:
        calls_d[lookup] = row['call?']
        puts_d[lookup] = row['put?']
c_dates = list(calls_d.keys()) 
c_vals = list(calls_d.values())
p_dates = list(puts_d.keys()) 
p_vals = list(puts_d.values())
plt.figure(figsize=(20,12))

plt.plot_date(c_dates, c_vals, '-', label = "calls")
plt.plot_date(p_dates, p_vals, '-', label = "puts")
plt.legend(loc = "upper left")
plt.title("Calls v Puts")

Text(0.5, 1.0, 'Calls v Puts')

#sentiment for a given stock
def stock_sentiment(s):
    sentiment = {}
    for i, row in wsb.iterrows():
        if s in row['tickers']:
            search = row['comment'].upper()
            datetime = str(row['time'].date())
            
            call_up = 0
            put_down = 0
            
            if 'CALL' in search or 'CALLS' in search or 'BOUGHT' in search or 'UP' in search or 'LONG' in search or 'BEAR' in search or 'BEARS' in search:
                call_up = 1
            if "PUT" in search or "PUTS" in search or "SOLD" in search or "DOWN" in search or "SHORT" in search or "BULL" in search or 'BULLS' in search:
                put_down = 1

                
            if datetime in sentiment:
                sentiment[datetime] = sentiment[datetime] + call_up - put_down
            else:
                sentiment[datetime] = call_up - put_down
                
          
    dates = list(sentiment.keys())
    vals = list(sentiment.values())
    
   
    return (dates, vals)

Here we will fit prices to dates, interest, and sentiment via linear regression(OLS). To understand future trajectory of the most mentioned stocks.

This function will try and fit prices with time to predict future prices

def lin_reg_time(s):
    
    clf = linear_model.LinearRegression()

    df = data.filter([('Close', s)])
    prices = []

    datetimes = []
    array = []

    for d in df.iloc[:,0]:
        if not math.isnan(d):
            prices.append(d)
            array.append(1)
        else:
            array.append(-1)
        
    index = 0
        
    for i,j in df.iterrows():
        if array[index] == 1:
            datetimes.append(i.date())
        index = index+1
        
    

    plt.figure(figsize=(20,12))

    plt.plot(datetimes, prices, 'o')
    

    datetimes_ = []
    
    for day in datetimes:
        datetimes_.append([day.day])
    
    clf.fit(datetimes_, prices)


    predict = clf.predict(datetimes_)

    plt.plot(datetimes,predict)
    plt.title("price of " + s +  " over time")
    plt.xlabel("day")
    plt.ylabel("price")
    plt.show()
    print("R^2: " + str(clf.score(datetimes_,prices)))

This function will try and fit prices with interest to predict future prices. Interest is measured as the number of times a stock is mentioned by name

def lin_reg_interest(s):
    clf = linear_model.LinearRegression()
        
    stock_count = {}
    #counting up stock mentions
    for index, row in wsb.iterrows():
        if s in row['tickers']:
            date = str(row['time'].date())
            if date in stock_count:
                stock_count[date] = stock_count[date] + 1
            else:
                stock_count[date] = 1
        
    

    df = data.filter([('Close', s)])
    
    
    toAppend = []
    
    
    for i, row in df.iterrows():
        if str(i.date()) in stock_count:
            toAppend.append(stock_count[str(i.date())])
        else:
            toAppend.append(0)
    
    prices = []

    index = 0
    
    for i,j in df.iterrows():
        if not math.isnan(j):
            prices.append(j)
        else:
            toAppend[index] = -1
        index = index+1
        
    interest_ = []
    
    for i in toAppend:
        if  i != -1:
            interest_.append([i])
        
    
    plt.figure(figsize=(20,12))

    plt.plot(interest_, prices, 'o')

    clf.fit(interest_, prices)

    predict = clf.predict(interest_)

    plt.plot(interest_,predict)
    plt.title("price of " + s +  " versus interest")
    plt.xlabel("Interest")
    plt.ylabel("Price")
    plt.show()
    print("R^2: " + str(clf.score(interest_,prices)))

This function will try and fit prices with sentiment as measured by the stock_sentiment function defined earlier.

def lin_reg_sentiment(s):
    clf = linear_model.LinearRegression()

    #vals is sentiment
    (dates, vals) = stock_sentiment(s)
    df = data.filter([('Close', s)])

    prices = []
            
    for i in df[("Close",s)]:
        if not math.isnan(i):
            prices.append(i)

    if(len(vals) < len(prices)):
        prices = prices[0:len(vals)]
    else:
        prices.append(0)
    
    plt.figure(figsize=(20,12))

    plt.plot(vals, prices, 'o')

    vals_ = []
    for v in vals:
        vals_.append([v])
    
  
    clf.fit(vals_, prices)
    
    predict = clf.predict(vals_)

    plt.plot(vals_,predict)
    plt.title("price of " + s +  " versus Sentiment")
    plt.xlabel("Sentiment")
    plt.ylabel("Price")
    plt.show()
    print("R^2: " + str(clf.score(vals_,prices)))

Running linear regressions on some sample stocks

These graphs can give us some general observations of stock prices during this time period. We observe PLTR, TSLA and ABNB having an overall positive trend in price over this time period while GME and NIO have an overall negative trend. We also observe that sentiment and interest can have varying effects on a stock's price. The 2 most discussed stocks - PLTR and TSLA - show a distinct negative trend in price as sentiment and interest increase. For NIO and ABNB the relationship between sentiment and interest and price appears slightly positive. Finally, GME shows a negative relationship between sentiment and price but a positive relationship between interest and price.

Overall, the plots with the highest R^2 value are the price of TSLA over time, price of GME versus interest and the price of PLTR versus sentiment. the TSLA over time plot has a R^2 value of .622 which indicates that about 62% of the variance in price is explaiend by our linear regression model. GME versus interest has a R^2 value of .599 and PLTR versus sentiment has a value of .352

From this we can see that the price of GME and PLTR have an interesting relationship with the reddit comments. As more people talked about GME its price increased even if the sentiment may not have been positive. For PLTR it seems that as more people discussed the stock in a positive note and made calls, its price appears to have went down instead.

for i in range(0, 5):
    lin_reg_time(fetch_stocks[i])
    lin_reg_sentiment(fetch_stocks[i])
    lin_reg_interest(fetch_stocks[i])

R^2: 0.20207202141820213

R^2: 0.35188220368961665

R^2: 0.03182951227950592

R^2: 0.621642420302355

R^2: 0.013109995891460113

R^2: 0.0027031199785544358

R^2: 0.3583700596156256

R^2: 0.09644515751117544

R^2: 0.598769084391083

R^2: 0.0420395194849722

R^2: 0.14935202329960018

R^2: 0.1827067435439529

R^2: 0.07701898734478718

R^2: 0.07284100522974857

R^2: 0.0335041936754229

Understanding good comments with ML

In the following cells we will be attempting to understand what makes a good comment on wall street bets. The importance of understand what makes good comments is based around the idea of limiting the scope of the data we need to look at. If we can understand what good comments look like then we can further direct our attention to understanding what the best traders on wall street bets are doing with their money.

In order to create a model we needed to hand label some comments as due diligence before feeding it into our function. This google sheets holds the first 100 comments in our dataframe that we will be using to train our model and comments will be labeled as 1 for good due diligence and 0 otherwise. this is what our y_data is. https://docs.google.com/spreadsheets/d/1IxiC7zmHTIi1bRlFQdGo03pC5it5eoVvODCzekALPBs/edit?usp=sharing

For our x_data we will go through each comment and measure 6 values. These values will be

1. Length of comment
2. Number of trigger words
3. Number of curse words
4. Number of capital letters
5. Number of upvotes
6. Number of replies

Trigger words will be common stock terminology such as "puts", "bull", "calls" and "short".

We will use a random forest classifier to differentiate between good and bad comments. The reason we chose the random forest classifier is that it handles dimensionality very well and in our model we have a lot of features to consider. In addition, it also handles collinearity really well which is something that we should expect within our data set. For example, a comment with high upvotes could influence its number of replies as well.

import pandas as pd
import statistics
import math
from sklearn.model_selection import train_test_split
from itertools import islice
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC


words = ['PUT','PUTS' ,'SOLD' ,'DOWN' , 'SHORT','BULL', 'BULLS', 'CALL' , 'CALLS' , 'BOUGHT' , 'UP', 'LONG', 'BEAR', 'BEARS']
    
curses = ["FUCK", "SHIT", "WTF"]

x_data = []

#labeled data
y_data = [0,0,0,0,0,1,0,0,0,1,
          0,0,0,0,1,0,1,0,0,0,
          0,0,0,1,1,0,0,1,0,1,
          0,0,0,0,0,1,0,0,0,0,
          0,0,0,0,1,0,1,0,0,0,
          0,1,0,1,1,0,0,0,0,0,
          0,0,0,1,0,1,1,0,0,0,
          0,0,0,1,0,0,0,1,0,0,
          1,0,1,0,1,0,1,0,1,1,
          0,0,0,0,0,0,0,0,0,0]


for i, row in islice(wsb.iterrows(), 0, 100):
    comment = row['comment']
    capital_comment = comment.upper()
    to_append = []
    
    #measuring length of comment
    to_append.append(len(comment))
         
    #counting up trigger words
    count = 0
    for word in words:
         if word in capital_comment:
            count = count + capital_comment.count(word)
    to_append.append(count)
    
    #counting up curse words
    curse_count = 0
    for curse in curses:
        if curse in capital_comment:
            curse_count = curse_count + capital_comment.count(curse)
    to_append.append(curse_count)
    capital_count = 0
    
    #counting up captital letters
    to_append.append(sum(1 for c in comment if c.isupper()))
    
    #upvotes of comment
    to_append.append(row['upvotes'])
    #replies to comment
    to_append.append(row['interaction'])
  
    x_data.append(to_append)

x_train, x_final, y_train, y_final = train_test_split(x_data,y_data,test_size = .5)

forest = RandomForestClassifier(n_estimators = 100, criterion = 'gini')
forest.fit(x_train, y_train)
res1 = forest.predict(x_final)
print(res1)
print(forest.score(x_final, y_final))

scores2 = cross_val_score(forest, x_final, y_final, cv=10)
print("Accuracy: %0.2f (+/- %0.2f)" % (scores2.mean(), scores2.std() * 2))

# Paired T-Test Calculation
def p_test(res2, y_final):
    diff = []
    for i in range(len(res2)): 
        diff.append(res2[i] - y_final[i])

    print("t = ",(sum(diff)/len(diff))/(np.std(diff)/math.sqrt(len(diff))))


p_test(res1, y_final)

[0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
 0 0 0 0 0 0 0 0 0 0 1 0 0]
0.76
Accuracy: 0.66 (+/- 0.31)
t =  -3.973597071195131

Our random forests model can predict whether a given comment is good due diligence with an average accuracy of around 60-70%. Furthermore, we see that our t value is -3.9 which is very far from 0. With this we can assume that our model is working as getting the same results with this t value would be unlikely if the model were not working. We can use this model to analyze a user's comments and then determine what analysis is the most useful to utilize in future trades.

Conclusion

Our initial observations of the subreddit wall street bets indicates that there is a strong prevalance of "bullish" sentiment and a large amount of discussion on rising stock prices and placing calls. In addition, discussion on stocks in this period is dominated by a few key companies, most notably "PLTR".

Based off our earlier observations and analysis we can see that metrics such as interest and sentiment can be a solid indicator for certain stock's performance although this may not always be a positive relationship.

Finally, our random forests model has taken the data that we have observed and analyzed and attempted to form a model to differentiate between the relevant comments and the purely speculative comments that are so pervasive on the subreddit. This model can be quite useful in working with large sets of comments and needing to find the content and analysis that is relevant to actual stock traders and analysts.

The stock market can be very volatile and highly unpredictable in times like these and predictions and models such as the ones we presented may not be 100% accurate. The factors that can affect a stock's price are numerous and the way they interact can be extremely complex. However, we can try to understand at least one small part of what determines stock prices and how people come to their opinion of a stock through sentiment analysis. We hope that this tutorial has provided some insight and understanding into this topic.

You can learn more about using sentiment analysis for understanding the stock market at the following links:

Sentiment Analysis of Stocks from Financial News using Python

click here to read more

How Sentiment Analysis in Stock Market Used for Right Prediction?

click here to read more