talksik/project5-machinelearning
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

adding in setup files

Browse Source
This commit is contained in:
Arjun Patel
2019-05-01 00:07:11 -07:00
parent 724b6dead8
commit 20b62927b5
9 changed files with 1730 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
models.py
+282
View File
@@ -0,0 +1,282 @@
import nn
import backend
import numpy as np
class PerceptronModel(object):
def __init__(self, dimensions):
"""
Initialize a new Perceptron instance.
A perceptron classifies data points as either belonging to a particular
class (+1) or not (-1). `dimensions` is the dimensionality of the data.
For example, dimensions=2 would mean that the perceptron must classify
2D points.
"""
self.w = nn.Parameter(1, dimensions)
def get_weights(self):
"""
Return a Parameter instance with the current weights of the perceptron.
"""
return self.w
def run(self, x):
"""
Calculates the score assigned by the perceptron to a data point x.
Inputs:
x: a node with shape (1 x dimensions)
Returns: a node containing a single number (the score)
"""
"*** YOUR CODE HERE ***"
def get_prediction(self, x):
"""
Calculates the predicted class for a single data point `x`.
Returns: 1 or -1
"""
"*** YOUR CODE HERE ***"
def train(self, dataset):
"""
Train the perceptron until convergence.
"""
"*** YOUR CODE HERE ***"
class RegressionModel(object):
"""
A neural network model for approximating a function that maps from real
numbers to real numbers. The network should be sufficiently large to be able
to approximate sin(x) on the interval [-2pi, 2pi] to reasonable precision.
"""
def __init__(self):
# Initialize your model parameters here
"*** YOUR CODE HERE ***"
model = object.__init__(self)
self.get_data_and_monitor = backend.RegressionDataset(model)
# Remember to set self.learning_rate!
# You may use any learning rate that works well for your architecture
"*** YOUR CODE HERE ***"
self.learning_rate = 0.1
self.hidden_size = 300
self.w1 = nn.Parameter(1, self.hidden_size)
self.w2 = nn.Parameter(self.hidden_size, self.hidden_size)
self.w3 = nn.Parameter(self.hidden_size, 1)
self.b1 = nn.Parameter(self.hidden_size)
self.b2 = nn.Parameter(self.hidden_size)
self.b3 = nn.Parameter(1)
def run(self, x):
"""
Runs the model for a batch of examples.
Inputs:
x: a node with shape (batch_size x 1)
Returns:
A node with shape (batch_size x 1) containing predicted y-values
"""
"*** YOUR CODE HERE ***"
self.graph = nn.Graph(
[self.w1, self.w2, self.w3, self.b1, self.b2, self.b3])
if y is not None:
# At training time, the correct output `y` is known.
# Here, you should construct a loss node, and return the nn.Graph
# that the node belongs to. The loss node must be the last node
# added to the graph.
"*** YOUR CODE HERE ***"
input_x = nn.Input(self.graph, x)
input_y = nn.Input(self.graph, y)
xw1 = nn.MatrixMultiply(self.graph, input_x, self.w1)
xw1_plus_b1 = nn.MatrixVectorAdd(self.graph, xw1, self.b1)
l1 = nn.ReLU(self.graph, xw1_plus_b1)
l1w2 = nn.MatrixMultiply(self.graph, l1, self.w2)
l2w2_plus_b2 = nn.MatrixVectorAdd(self.graph, l1w2, self.b2)
l2 = nn.ReLU(self.graph, l2w2_plus_b2)
l2w3 = nn.MatrixMultiply(self.graph, l2, self.w3)
l2w3_plus_b3 = nn.MatrixVectorAdd(self.graph, l2w3, self.b3)
loss = nn.SquareLoss(self.graph, l2w3_plus_b3, input_y)
return self.graph
else:
# At test time, the correct output is unknown.
# You should instead return your model's prediction as a numpy array
"*** YOUR CODE HERE ***"
input_x = nn.Input(self.graph, x)
xw1 = nn.MatrixMultiply(self.graph, input_x, self.w1)
xw1_plus_b1 = nn.MatrixVectorAdd(self.graph, xw1, self.b1)
l1 = nn.ReLU(self.graph, xw1_plus_b1)
l1w2 = nn.MatrixMultiply(self.graph, l1, self.w2)
l2w2_plus_b2 = nn.MatrixVectorAdd(self.graph, l1w2, self.b2)
l2 = nn.ReLU(self.graph, l2w2_plus_b2)
l2w3 = nn.MatrixMultiply(self.graph, l2, self.w3)
l2w3_plus_b3 = nn.MatrixVectorAdd(self.graph, l2w3, self.b3)
return self.graph.get_output(l2w3_plus_b3)
def get_loss(self, x, y):
"""
Computes the loss for a batch of examples.
Inputs:
x: a node with shape (batch_size x 1)
y: a node with shape (batch_size x 1), containing the true y-values
to be used for training
Returns: a loss node
"""
"*** YOUR CODE HERE ***"
def train(self, dataset):
"""
Trains the model.
"""
"*** YOUR CODE HERE ***"
class DigitClassificationModel(object):
"""
A model for handwritten digit classification using the MNIST dataset.
Each handwritten digit is a 28x28 pixel grayscale image, which is flattened
into a 784-dimensional vector for the purposes of this model. Each entry in
the vector is a floating point number between 0 and 1.
The goal is to sort each digit into one of 10 classes (number 0 through 9).
(See RegressionModel for more information about the APIs of different
methods here. We recommend that you implement the RegressionModel before
working on this part of the project.)
"""
def __init__(self):
# Initialize your model parameters here
"*** YOUR CODE HERE ***"
object.__init__(self)
self.get_data_and_monitor = backend.DigitClassificationDataset
self.learning_rate = 0.15
self.hidden_size = 300
self.w1 = nn.Parameter(784, self.hidden_size)
self.w2 = nn.Parameter(self.hidden_size, self.hidden_size)
self.w3 = nn.Parameter(self.hidden_size, 10)
self.b1 = nn.Parameter(1, self.hidden_size)
self.b2 = nn.Parameter(1, self.hidden_size)
self.b3 = nn.Parameter(1, 10)
def run(self, x):
"""
Runs the model for a batch of examples.
Your model should predict a node with shape (batch_size x 10),
containing scores. Higher scores correspond to greater probability of
the image belonging to a particular class.
Inputs:
x: a node with shape (batch_size x 784)
Output:
A node with shape (batch_size x 10) containing predicted scores
(also called logits)
"""
"*** YOUR CODE HERE ***"
def get_loss(self, x, y):
"""
Computes the loss for a batch of examples.
The correct labels `y` are represented as a node with shape
(batch_size x 10). Each row is a one-hot vector encoding the correct
digit class (0-9).
Inputs:
x: a node with shape (batch_size x 784)
y: a node with shape (batch_size x 10)
Returns: a loss node
"""
"*** YOUR CODE HERE ***"
def train(self, dataset):
"""
Trains the model.
"""
"*** YOUR CODE HERE ***"
class LanguageIDModel(object):
"""
A model for language identification at a single-word granularity.
(See RegressionModel for more information about the APIs of different
methods here. We recommend that you implement the RegressionModel before
working on this part of the project.)
"""
def __init__(self):
# Our dataset contains words from five different languages, and the
# combined alphabets of the five languages contain a total of 47 unique
# characters.
# You can refer to self.num_chars or len(self.languages) in your code
self.num_chars = 47
self.languages = ["English", "Spanish", "Finnish", "Dutch", "Polish"]
# Initialize your model parameters here
"*** YOUR CODE HERE ***"
def run(self, xs):
"""
Runs the model for a batch of examples.
Although words have different lengths, our data processing guarantees
that within a single batch, all words will be of the same length (L).
Here `xs` will be a list of length L. Each element of `xs` will be a
node with shape (batch_size x self.num_chars), where every row in the
array is a one-hot vector encoding of a character. For example, if we
have a batch of 8 three-letter words where the last word is "cat", then
xs[1] will be a node that contains a 1 at position (7, 0). Here the
index 7 reflects the fact that "cat" is the last word in the batch, and
the index 0 reflects the fact that the letter "a" is the inital (0th)
letter of our combined alphabet for this task.
Your model should use a Recurrent Neural Network to summarize the list
`xs` into a single node of shape (batch_size x hidden_size), for your
choice of hidden_size. It should then calculate a node of shape
(batch_size x 5) containing scores, where higher scores correspond to
greater probability of the word originating from a particular language.
Inputs:
xs: a list with L elements (one per character), where each element
is a node with shape (batch_size x self.num_chars)
Returns:
A node with shape (batch_size x 5) containing predicted scores
(also called logits)
"""
"*** YOUR CODE HERE ***"
def get_loss(self, xs, y):
"""
Computes the loss for a batch of examples.
The correct labels `y` are represented as a node with shape
(batch_size x 5). Each row is a one-hot vector encoding the correct
language.
Inputs:
xs: a list with L elements (one per character), where each element
is a node with shape (batch_size x self.num_chars)
y: a node with shape (batch_size x 5)
Returns: a loss node
"""
"*** YOUR CODE HERE ***"
def train(self, dataset):
"""
Trains the model.
"""
"*** YOUR CODE HERE ***"