def get_prediction(self, x): """ Calculates the predicted class for a single data point `x`. Returns: 1 or -1 """ return 1.0 if nn.as_scalar(nn.DotProduct(x, self.w)) >= 0 else -1.0
def get_prediction(self, x): """ Calculates the predicted class for a single data point `x`. Returns: 1 or -1 """ "*** YOUR CODE HERE ***" return 1 if nn.as_scalar(nn.DotProduct(self.w, x)) >= 0 else -1
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) """ return nn.DotProduct(x, self.get_weights())
def train(self, dataset): """ Train the perceptron until convergence. """ done = False while not done: # iterates until none of the products w*x*y are <= 0 done = True for item in dataset.iterate_once(1): x = item[0] y = item[1] prod1 = nn.DotProduct(x, self.w) prod2 = nn.DotProduct(prod1, y) if nn.as_scalar(prod2) <= 0: done = False prediction = self.get_prediction(x) # update weights self.w.update(x, prediction)
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 ***" return nn.DotProduct(self.w, x)
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 ***" # using computing the dot product over the default weights with the values from the dataset return nn.DotProduct(self.get_weights(), x)
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) Deberiais obtener el producto escalar (o producto punto) que es "equivalente" a la distancia del coseno """ "*** YOUR CODE HERE ***" return nn.DotProduct(self.w, x)
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 ***" # Compute dot product between weights and the input. return nn.DotProduct(x, self.get_weights())
def get_prediction(self, x): """ Calculates the predicted class for a single data point `x`. Returns: 1 or -1 """ "*** YOUR CODE HERE ***" scalar = nn.DotProduct(x, self.w) if nn.as_scalar(scalar) >= 0: return 1 else: return -1
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 ***" # return the score - i.e the the dot product of the given weight and the weight vector score = nn.DotProduct(x, self.get_weights()) return score
def get_prediction(self, x): """ Calculates the predicted class for a single data point `x`. Returns: 1 or -1 """ "*** YOUR CODE HERE ***" temp = nn.DotProduct(self.w,x) if (nn.as_scalar(temp) > -0.000001): return 1 else: return -1
def train(self, dataset): """ Trains the model. """ "*** YOUR CODE HERE ***" #just an arbitrary nonzero loss node loss = nn.DotProduct(self.w1, self.w1) while nn.as_scalar(loss) >= .00001: for x, y in dataset.iterate_once(self.batch_size): loss = self.get_loss(x, y) gradients = nn.gradients(loss, self.weights) for i in range(len(self.weights)): self.weights[i].update(gradients[i], -self.learning_rate)
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 ***" #print("Printing x (input)") #print(x) #print("Printing w (self.weights)") #print(self.w) return nn.DotProduct(x, self.w)
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 ***" #first summarize xs into vector z_curr = nn.DotProduct(self.w, xs[0]) h_curr = self.f_initial(xs[0]) for i in range(1, len(xs)): z_curr = nn.Add(nn.Linear(xs[i], self.w), nn.Linear(h_curr, self.w_hidden)) h_curr = z_curr return z_curr
def run(self, x): return nn.DotProduct(self.w, x)