Sentiment Classification & How To "Frame Problems" for a Neural Network

by Andrew Trask

Twitter: @iamtrask
Blog: http://iamtrask.github.io

What You Should Already Know

neural networks, forward and back-propagation
stochastic gradient descent
mean squared error
and train/test splits

Where to Get Help if You Need it

Re-watch previous Udacity Lectures
Leverage the recommended Course Reading Material - Grokking Deep Learning (40% Off: traskud17)
Shoot me a tweet @iamtrask

Tutorial Outline:

Intro: The Importance of "Framing a Problem"

Curate a Dataset
Developing a "Predictive Theory"
PROJECT 1: Quick Theory Validation

Transforming Text to Numbers
PROJECT 2: Creating the Input/Output Data

Putting it all together in a Neural Network
PROJECT 3: Building our Neural Network

Understanding Neural Noise
PROJECT 4: Making Learning Faster by Reducing Noise

Analyzing Inefficiencies in our Network
PROJECT 5: Making our Network Train and Run Faster

Further Noise Reduction
PROJECT 6: Reducing Noise by Strategically Reducing the Vocabulary

Analysis: What's going on in the weights?

Lesson: Curate a Dataset



In [1]:

    
def pretty_print_review_and_label(i):
    print(labels[i] + "\t:\t" + reviews[i][:80] + "...")

g = open('reviews.txt','r') # What we know!
reviews = list(map(lambda x:x[:-1],g.readlines()))
g.close()

g = open('labels.txt','r') # What we WANT to know!
labels = list(map(lambda x:x[:-1].upper(),g.readlines()))
g.close()



In [2]:

    
len(reviews)









    Out[2]:





25000



In [3]:

    
reviews[0]









    Out[3]:





'bromwell high is a cartoon comedy . it ran at the same time as some other programs about school life  such as  teachers  . my   years in the teaching profession lead me to believe that bromwell high  s satire is much closer to reality than is  teachers  . the scramble to survive financially  the insightful students who can see right through their pathetic teachers  pomp  the pettiness of the whole situation  all remind me of the schools i knew and their students . when i saw the episode in which a student repeatedly tried to burn down the school  i immediately recalled . . . . . . . . . at . . . . . . . . . . high . a classic line inspector i  m here to sack one of your teachers . student welcome to bromwell high . i expect that many adults of my age think that bromwell high is far fetched . what a pity that it isn  t   '



In [4]:

    
labels[0]









    Out[4]:





'POSITIVE'

Lesson: Develop a Predictive Theory



In [5]:

    
print("labels.txt \t : \t reviews.txt\n")
pretty_print_review_and_label(2137)
pretty_print_review_and_label(12816)
pretty_print_review_and_label(6267)
pretty_print_review_and_label(21934)
pretty_print_review_and_label(5297)
pretty_print_review_and_label(4998)









    



labels.txt 	 : 	 reviews.txt

NEGATIVE	:	this movie is terrible but it has some good effects .  ...
POSITIVE	:	adrian pasdar is excellent is this film . he makes a fascinating woman .  ...
NEGATIVE	:	comment this movie is impossible . is terrible  very improbable  bad interpretat...
POSITIVE	:	excellent episode movie ala pulp fiction .  days   suicides . it doesnt get more...
NEGATIVE	:	if you haven  t seen this  it  s terrible . it is pure trash . i saw this about ...
POSITIVE	:	this schiffer guy is a real genius  the movie is of excellent quality and both e...

Project 1: Quick Theory Validation



In [6]:

    
from collections import Counter
import numpy as np



In [7]:

    
positive_counts = Counter()
negative_counts = Counter()
total_counts = Counter()



In [8]:

    
for i in range(len(reviews)):
    if(labels[i] == 'POSITIVE'):
        for word in reviews[i].split(" "):
            positive_counts[word] += 1
            total_counts[word] += 1
    else:
        for word in reviews[i].split(" "):
            negative_counts[word] += 1
            total_counts[word] += 1



In [9]:

    
# positive_counts.most_common()



In [10]:

    
pos_neg_ratios = Counter()

for term,cnt in list(total_counts.most_common()):
    if(cnt > 100):
        pos_neg_ratio = positive_counts[term] / float(negative_counts[term]+1)
        pos_neg_ratios[term] = pos_neg_ratio

for word,ratio in pos_neg_ratios.most_common():
    if(ratio > 1):
        pos_neg_ratios[word] = np.log(ratio)
    else:
        pos_neg_ratios[word] = -np.log((1 / (ratio+0.01)))



In [11]:

    
# words most frequently seen in a review with a "POSITIVE" label
# pos_neg_ratios.most_common()



In [12]:

    
# words most frequently seen in a review with a "NEGATIVE" label
# list(reversed(pos_neg_ratios.most_common()))[0:30]

Transforming Text into Numbers



In [13]:

    
from IPython.display import Image

review = "This was a horrible, terrible movie."

Image(filename='sentiment_network.png')









    Out[13]:



In [14]:

    
review = "The movie was excellent"

Image(filename='sentiment_network_pos.png')









    Out[14]:

Project 2: Creating the Input/Output Data



In [15]:

    
vocab = set(total_counts.keys())
vocab_size = len(vocab)
print(vocab_size)



In [16]:

    
# list(vocab)



In [17]:

    
import numpy as np

layer_0 = np.zeros((1,vocab_size))
layer_0









    Out[17]:





array([[ 0.,  0.,  0., ...,  0.,  0.,  0.]])



In [18]:

    
from IPython.display import Image
Image(filename='sentiment_network.png')









    Out[18]:



In [19]:

    
word2index = {}

for i,word in enumerate(vocab):
    word2index[word] = i
    
# word2index



In [20]:

    
def update_input_layer(review):
    
    global layer_0
    
    # clear out previous state, reset the layer to be all 0s
    layer_0 *= 0
    for word in review.split(" "):
        layer_0[0][word2index[word]] += 1

update_input_layer(reviews[0])



In [21]:

    
layer_0









    Out[21]:





array([[ 18.,   0.,   0., ...,   0.,   0.,   0.]])



In [22]:

    
def get_target_for_label(label):
    if(label == 'POSITIVE'):
        return 1
    else:
        return 0



In [23]:

    
labels[0]









    Out[23]:





'POSITIVE'



In [24]:

    
get_target_for_label(labels[0])









    Out[24]:





1



In [25]:

    
labels[1]









    Out[25]:





'NEGATIVE'



In [26]:

    
get_target_for_label(labels[1])









    Out[26]:





0

Project 3: Building a Neural Network

Start with your neural network from the last chapter
3 layer neural network
no non-linearity in hidden layer
use our functions to create the training data
create a "pre_process_data" function to create vocabulary for our training data generating functions
modify "train" to train over the entire corpus

Where to Get Help if You Need it

Re-watch previous week's Udacity Lectures
Chapters 3-5 - Grokking Deep Learning - (40% Off: traskud17)



In [27]:

    
import time
import sys
import numpy as np

# Let's tweak our network from before to model these phenomena
class SentimentNetwork:
    def __init__(self, reviews,labels,hidden_nodes = 10, learning_rate = 0.1):
       
        # set our random number generator 
        np.random.seed(1)
    
        self.pre_process_data(reviews, labels)
        
        self.init_network(len(self.review_vocab),hidden_nodes, 1, learning_rate)
        
        
    def pre_process_data(self, reviews, labels):
        
        review_vocab = set()
        for review in reviews:
            for word in review.split(" "):
                review_vocab.add(word)
        self.review_vocab = list(review_vocab)
        
        label_vocab = set()
        for label in labels:
            label_vocab.add(label)
        
        self.label_vocab = list(label_vocab)
        
        self.review_vocab_size = len(self.review_vocab)
        self.label_vocab_size = len(self.label_vocab)
        
        self.word2index = {}
        for i, word in enumerate(self.review_vocab):
            self.word2index[word] = i
        
        self.label2index = {}
        for i, label in enumerate(self.label_vocab):
            self.label2index[label] = i
         
        
    def init_network(self, input_nodes, hidden_nodes, output_nodes, learning_rate):
        # Set number of nodes in input, hidden and output layers.
        self.input_nodes = input_nodes
        self.hidden_nodes = hidden_nodes
        self.output_nodes = output_nodes

        # Initialize weights
        self.weights_0_1 = np.zeros((self.input_nodes,self.hidden_nodes))
    
        self.weights_1_2 = np.random.normal(0.0, self.output_nodes**-0.5, 
                                                (self.hidden_nodes, self.output_nodes))
        
        self.learning_rate = learning_rate
        
        self.layer_0 = np.zeros((1,input_nodes))
        self.layer_1 = np.zeros((1, hidden_nodes))
    
        
    def update_input_layer(self,review):

        # clear out previous state, reset the layer to be all 0s
        self.layer_0 *= 0
        for word in review.split(" "):
            if(word in self.word2index.keys()):
                self.layer_0[0][self.word2index[word]] += 1
                
    def get_target_for_label(self,label):
        if(label == 'POSITIVE'):
            return 1
        else:
            return 0
        
    def sigmoid(self,x):
        return 1 / (1 + np.exp(-x))
    
    
    def sigmoid_output_2_derivative(self,output):
        return output * (1 - output)
    
    def train(self, training_reviews_raw, training_labels):
        
        # Performance pre-processing
        training_reviews = list()
        for review in training_reviews_raw:
            indices = set()
            
            for word in review.split(" "):
                if(word in self.word2index.keys()):
                    indices.add(self.word2index[word])
            training_reviews.append(list(indices))
        
        
        assert(len(training_reviews) == len(training_labels))
        
        correct_so_far = 0
        
        start = time.time()
        
        for i in range(len(training_reviews)):
            
            review = training_reviews[i]
            label = training_labels[i]
            
            #### Implement the forward pass here ####
            ### Forward pass ###

            # Input Layer
            # Handled in performance pre processsing
            # self.update_input_layer(review)

            # Hidden layer
            self.layer_1 *= 0
            for index in review:
                self.layer_1 += self.weights_0_1[index]

            # Output layer
            layer_2 = self.sigmoid(self.layer_1.dot(self.weights_1_2))

            #### Implement the backward pass here ####
            ### Backward pass ###

            # TODO: Output error
            layer_2_error = layer_2 - self.get_target_for_label(label) # Output layer error is the difference between desired target and actual output.
            layer_2_delta = layer_2_error * self.sigmoid_output_2_derivative(layer_2)

            # TODO: Backpropagated error
            layer_1_error = layer_2_delta.dot(self.weights_1_2.T) # errors propagated to the hidden layer
            layer_1_delta = layer_1_error # hidden layer gradients - no nonlinearity so it's the same as the error

            # TODO: Update the weights
            self.weights_1_2 -= self.layer_1.T.dot(layer_2_delta) * self.learning_rate # update hidden-to-output weights with gradient descent step
            self.weights_0_1 -= self.layer_0.T.dot(layer_1_delta) * self.learning_rate # update input-to-hidden weights with gradient descent step

            if(np.abs(layer_2_error) < 0.5):
                correct_so_far += 1
            
            reviews_per_second = i / float(time.time() - start)
            
            sys.stdout.write("\rProgress:" + str(100 * i/float(len(training_reviews)))[:4] + "% Speed(reviews/sec):" + str(reviews_per_second)[0:5] + " #Correct:" + str(correct_so_far) + " #Trained:" + str(i+1) + " Training Accuracy:" + str(correct_so_far * 100 / float(i+1))[:4] + "%")
            if(i % 2500 == 0):
                print("")
    
    def test(self, testing_reviews, testing_labels):
        
        correct = 0
        
        start = time.time()
        
        for i in range(len(testing_reviews)):
            pred = self.run(testing_reviews[i])
            if(pred == testing_labels[i]):
                correct += 1
            
            reviews_per_second = i / float(time.time() - start)
            
            sys.stdout.write("\rProgress:" + str(100 * i/float(len(testing_reviews)))[:4] \
                             + "% Speed(reviews/sec):" + str(reviews_per_second)[0:5] \
                            + "% #Correct:" + str(correct) + " #Tested:" + str(i+1) + " Testing Accuracy:" + str(correct * 100 / float(i+1))[:4] + "%")
    
    def run(self, review):
        
        # Input Layer
        self.update_input_layer(review.lower())

        # Hidden layer
        layer_1 = self.layer_0.dot(self.weights_0_1)

        # Output layer
        layer_2 = self.sigmoid(layer_1.dot(self.weights_1_2))
        
        if(layer_2[0] > 0.5):
            return "POSITIVE"
        else:
            return "NEGATIVE"



In [28]:

    
# mlp = SentimentNetwork(reviews[:-1000],labels[:-1000], learning_rate=0.1)



In [29]:

    
# evaluate our model before training (just to show how horrible it is)
# mlp.test(reviews[-1000:],labels[-1000:])



In [30]:

    
# train the network
# mlp.train(reviews[:-1000],labels[:-1000])



In [31]:

    
# mlp = SentimentNetwork(reviews[:-1000],labels[:-1000], learning_rate=0.01)



In [32]:

    
# train the network
# mlp.train(reviews[:-1000],labels[:-1000])



In [33]:

    
# mlp = SentimentNetwork(reviews[:-1000],labels[:-1000], learning_rate=0.001)



In [34]:

    
# train the network
# mlp.train(reviews[:-1000],labels[:-1000])

Understanding Neural Noise



In [35]:

    
from IPython.display import Image
Image(filename='sentiment_network.png')









    Out[35]:



In [36]:

    
def update_input_layer(review):
    
    global layer_0
    
    # clear out previous state, reset the layer to be all 0s
    layer_0 *= 0
    for word in review.split(" "):
        layer_0[0][word2index[word]] += 1

update_input_layer(reviews[0])



In [37]:

    
layer_0









    Out[37]:





array([[ 18.,   0.,   0., ...,   0.,   0.,   0.]])



In [38]:

    
review_counter = Counter()



In [39]:

    
for word in reviews[0].split(" "):
    review_counter[word] += 1



In [40]:

    
# review_counter.most_common()

Project 4: Reducing Noise in our Input Data



In [44]:

    
import time
import sys
import numpy as np

# Let's tweak our network from before to model these phenomena
class SentimentNetwork:
    def __init__(self, reviews,labels,hidden_nodes = 10, learning_rate = 0.1):
       
        # set our random number generator 
        np.random.seed(1)
    
        self.pre_process_data(reviews, labels)
        
        self.init_network(len(self.review_vocab),hidden_nodes, 1, learning_rate)
        
        
    def pre_process_data(self, reviews, labels):
        
        review_vocab = set()
        for review in reviews:
            for word in review.split(" "):
                review_vocab.add(word)
        self.review_vocab = list(review_vocab)
        
        label_vocab = set()
        for label in labels:
            label_vocab.add(label)
        
        self.label_vocab = list(label_vocab)
        
        self.review_vocab_size = len(self.review_vocab)
        self.label_vocab_size = len(self.label_vocab)
        
        self.word2index = {}
        for i, word in enumerate(self.review_vocab):
            self.word2index[word] = i
        
        self.label2index = {}
        for i, label in enumerate(self.label_vocab):
            self.label2index[label] = i
         
        
    def init_network(self, input_nodes, hidden_nodes, output_nodes, learning_rate):
        # Set number of nodes in input, hidden and output layers.
        self.input_nodes = input_nodes
        self.hidden_nodes = hidden_nodes
        self.output_nodes = output_nodes

        # Initialize weights
        self.weights_0_1 = np.zeros((self.input_nodes,self.hidden_nodes))
    
        self.weights_1_2 = np.random.normal(0.0, self.output_nodes**-0.5, 
                                                (self.hidden_nodes, self.output_nodes))
        
        self.learning_rate = learning_rate
        
        self.layer_0 = np.zeros((1,input_nodes))
        self.layer_1 = np.zeros((1,hidden_nodes))
    
        
    def update_input_layer(self,review):

        # clear out previous state, reset the layer to be all 0s
        self.layer_0 *= 0
        for word in review.split(" "):
            if(word in self.word2index.keys()):
                self.layer_0[0][self.word2index[word]] = 1
                
    def get_target_for_label(self,label):
        if(label == 'POSITIVE'):
            return 1
        else:
            return 0
        
    def sigmoid(self,x):
        return 1 / (1 + np.exp(-x))
    
    
    def sigmoid_output_2_derivative(self,output):
        return output * (1 - output)
    
    def train(self, training_reviews_raw, training_labels):
        
        # Performance pre-processing
        training_reviews = list()
        for review in training_reviews_raw:
            indices = set()
            
            for word in review.split(" "):
                if(word in self.word2index.keys()):
                    indices.add(self.word2index[word])
            training_reviews.append(list(indices))
        
        
        assert(len(training_reviews) == len(training_labels))
        
        correct_so_far = 0
        
        start = time.time()
        
        for i in range(len(training_reviews)):
            
            review = training_reviews[i]
            label = training_labels[i]
            
            #### Implement the forward pass here ####
            ### Forward pass ###

            # Input Layer
            # Remove as now performance preprocessing
            # self.update_input_layer(review)

            # Hidden layer
            self.layer_1 *= 0
            for index in review:
                self.layer_1 += self.weights_0_1[index]

            # Output layer
            layer_2 = self.sigmoid(self.layer_1.dot(self.weights_1_2))

            #### Implement the backward pass here ####
            ### Backward pass ###

            # Output error
            layer_2_error = layer_2 - self.get_target_for_label(label) # Output layer error is the difference between desired target and actual output.
            layer_2_delta = layer_2_error * self.sigmoid_output_2_derivative(layer_2)

            # Backpropagated error
            layer_1_error = layer_2_delta.dot(self.weights_1_2.T) # errors propagated to the hidden layer
            layer_1_delta = layer_1_error # hidden layer gradients - no nonlinearity so it's the same as the error

            # TODO: Update the weights
            self.weights_1_2 -= self.layer_1.T.dot(layer_2_delta) * self.learning_rate # update hidden-to-output weights with gradient descent step
            
            # Update with code below for better performance
            # self.weights_0_1 -= self.layer_0.T.dot(layer_1_delta) * self.learning_rate # update input-to-hidden weights with gradient descent step

            # only update weights we are USING
            for index in review:
                self.weights_0_1[index] -= layer_1_delta[0] * self.learning_rate
            
            
            if(np.abs(layer_2_error) < 0.5):
                correct_so_far += 1
            
            reviews_per_second = i / float(time.time() - start)
            
            sys.stdout.write("\rProgress:" + str(100 * i/float(len(training_reviews)))[:4] + "% Speed(reviews/sec):" + str(reviews_per_second)[0:5] + " #Correct:" + str(correct_so_far) + " #Trained:" + str(i+1) + " Training Accuracy:" + str(correct_so_far * 100 / float(i+1))[:4] + "%")
            if(i % 2500 == 0):
                print("")
    
    def test(self, testing_reviews, testing_labels):
        
        correct = 0
        
        start = time.time()
        
        for i in range(len(testing_reviews)):
            pred = self.run(testing_reviews[i])
            if(pred == testing_labels[i]):
                correct += 1
            
            reviews_per_second = i / float(time.time() - start)
            
            sys.stdout.write("\rProgress:" + str(100 * i/float(len(testing_reviews)))[:4] \
                             + "% Speed(reviews/sec):" + str(reviews_per_second)[0:5] \
                            + "% #Correct:" + str(correct) + " #Tested:" + str(i+1) + " Testing Accuracy:" + str(correct * 100 / float(i+1))[:4] + "%")
    
    def run(self, review):
        
        # Hidden layer
        self.layer_1 *= 0
        unique_indices = set()
        for word in review.lower().split(" "):
            if word in self.word2index.keys():
                unique_indices.add(self.word2index[word])
        for index in unique_indices:
            self.layer_1 += self.weights_0_1[index]
        

        # Output layer
        layer_2 = self.sigmoid(self.layer_1.dot(self.weights_1_2))
        
        if(layer_2[0] > 0.5):
            return "POSITIVE"
        else:
            return "NEGATIVE"



In [45]:

    
mlp = SentimentNetwork(reviews[:-1000],labels[:-1000], learning_rate=0.1)



In [53]:

    
mlp.train(reviews[:-1000],labels[:-1000])









    



Progress:0.0% Speed(reviews/sec):0.0 #Correct:1 #Trained:1 Training Accuracy:100.%
Progress:10.4% Speed(reviews/sec):1336. #Correct:2245 #Trained:2501 Training Accuracy:89.7%
Progress:20.8% Speed(reviews/sec):1316. #Correct:4498 #Trained:5001 Training Accuracy:89.9%
Progress:31.2% Speed(reviews/sec):1315. #Correct:6732 #Trained:7501 Training Accuracy:89.7%
Progress:41.6% Speed(reviews/sec):1327. #Correct:8982 #Trained:10001 Training Accuracy:89.8%
Progress:52.0% Speed(reviews/sec):1318. #Correct:11220 #Trained:12501 Training Accuracy:89.7%
Progress:62.5% Speed(reviews/sec):1317. #Correct:13488 #Trained:15001 Training Accuracy:89.9%
Progress:72.9% Speed(reviews/sec):1311. #Correct:15738 #Trained:17501 Training Accuracy:89.9%
Progress:83.3% Speed(reviews/sec):1304. #Correct:18034 #Trained:20001 Training Accuracy:90.1%
Progress:93.7% Speed(reviews/sec):1295. #Correct:20310 #Trained:22501 Training Accuracy:90.2%
Progress:99.9% Speed(reviews/sec):1293. #Correct:21684 #Trained:24000 Training Accuracy:90.3%



In [ ]:

    
# evaluate our model after training
time.clock()
mlp.test(reviews[-1000:],labels[-1000:])

Analyzing Inefficiencies in our Network



In [ ]:

    
Image(filename='sentiment_network_sparse.png')



In [ ]:

    
layer_0 = np.zeros(10)



In [ ]:

    
layer_0



In [ ]:

    
layer_0[4] = 1
layer_0[9] = 1



In [ ]:

    
layer_0



In [ ]:

    
weights_0_1 = np.random.randn(10,5)



In [ ]:

    
layer_0.dot(weights_0_1)



In [ ]:

    
indices = [4,9]



In [ ]:

    
layer_1 = np.zeros(5)



In [ ]:

    
for index in indices:
    layer_1 += (weights_0_1[index])



In [ ]:

    
layer_1



In [ ]:

    
Image(filename='sentiment_network_sparse_2.png')



In [ ]: