def __call__(self, x): """ Forward data through the network. This allows us to conveniently initialize a model `m` and then send data through it to be classified by calling `m(x)`. Parameters ---------- x : Union[numpy.ndarray, mygrad.Tensor], shape=(N, D, S) The data to forward through the network. Returns ------- mygrad.Tensor, shape=(N, 1) The model outputs. Notes ----- N = batch size D = embedding size S = sentence length """ # <COGINST> # (N, D, S) with D = 200 and S = 77 x = self.conv1(x) # conv output shape (N, F, S') with F = 250 and S' = 75 x = relu(x) x = max_pool(x, (x.shape[-1],), 1) # global pool output shape (N, F, S') with F = 250, S' = 1 x = x.reshape(x.shape[0], -1) # (N, F, 1) -> (N, F) x = self.dense1(x) # (N, F) @ (F, D1) = (N, D1) x = relu(x) x = self.dense2(x) # (N, D1) @ (D1, 1) = (N, 1) x = sigmoid(x) return x # output shape (N, 1)
def policyForward(self, data): data = mg.Tensor(data) x = self.conv1(data) x = self.conv2(x) x = relu(self.dense1(x.reshape(x.shape[0], -1))) x = relu(self.dense2(x)) return self.dense3(x)
def __call__(self, x): ''' Forward data through the network. This allows us to conveniently initialize a model `m` and then send data through it to be classified by calling `m(x)`. Parameters ---------- x : Union[numpy.ndarray, mygrad.Tensor], shape=(N, D) The data to forward through the network. Returns ------- mygrad.Tensor, shape=(N, 1) The model outputs. ''' # returns output of dense -> relu -> dense -> relu -> dense -> softmax three layer. temp1 = max_pool( self.conv2(relu(max_pool(self.conv1(x), pool=(2,2),stride=1))), pool=(2,2),stride=1) s = temp1.shape #print(temp1.shape) temp1 = temp1.reshape(s[0], s[1]*s[2]*s[3]) #print(temp1.shape) return self.dense3(relu(temp1))
def __call__(self, x): x = relu(self.conv1(x)) x = max_pool(relu(self.conv2(x)), (2, 2), (2, 2)) x = relu(self.conv3(x)) x = max_pool(relu(self.conv4(x)), (2, 2), (2, 2)) x = x.reshape(x.shape[0], 256) x = relu(self.dense1(x)) x = self.dense2(x) return x
def __call__(self, x): step1 = max_pool(relu(self.conv1(x)), (2, 2), stride=2) step2 = max_pool(relu(self.conv2(step1)), (2, 2), stride=2) flatten = step2.reshape(len(x), ) dense_layers = self.dense2(relu(self.dense1(flatten))) return dense_layers # returns output of dense -> relu -> dense -> relu -> dense -> softmax three layer. pass
def __call__(self, x): x = self.conv1(x) x = max_pool(x, (2, 2), 2) x = self.conv2(x) x = max_pool(x, (2, 2), 2) x = relu(self.dense1(x.reshape(x.shape[0], -1))) return self.dense2(x)
def __call__(self, x): ''' Forward data through the network. This allows us to conveniently initialize a model `m` and then send data through it to be classified by calling `m(x)`. Parameters ---------- x : Union[numpy.ndarray, mygrad.Tensor], shape=(N, D) The data to forward through the network. Returns ------- mygrad.Tensor, shape=(N, 1) The model outputs. ''' # STUDENT CODE # if num_filters = 10; (N, C, 32, 32) --> (N, 10, 28, 28) # if num_filters = 10; (N, C, 32, 32) --> (N, 10, 28, 28) x = self.conv1(x) # (N, 10, 28, 28) --> (N, 10, 14, 14) x = max_pool(x, (2,2), 2) # if num_filters = 20; (N, 10, 14, 14) --> (N, 20, 10, 10) x = self.conv2(x) # (N, 20, 10, 10) --> (N, 20, 5, 5) x = max_pool(x, (2,2), 2) # (N, 20, 5, 5) -reshape-> (N, 500) x (500, 20) -> (N, 20) x = relu(self.dense1(x.reshape(x.shape[0], -1))) # (N, 20) -> (N, 10) return self.dense2(x)
def __call__(self, x): ''' Defines a forward pass of the model. Parameters ---------- x : numpy.ndarray, shape=(N, 1, 28, 28) The input data, where N is the number of images. Returns ------- mygrad.Tensor, shape=(N, 10) The class scores for each of the N images. Pseudo-code ----------- >>> create dropout object >>> compute the first convolutional layer by doing x.conv1 >>> Perform ReLU by using relu(x) >>> Perform dropout by using x.dropout() >>> Use max_pool(x, size_pool, stride) to perform the pooling layer >>> repeat once >>> perform two dense layers with ReLU dropout in between ''' #first conv layer x = self.conv1(x) x = relu(x) x = self.dropout(x) x = max_pool(x, (2, 2), 2) #second conv layer x = self.conv2(x) x = relu(x) x = self.dropout(x) x = max_pool(x, (2, 2), 2) #performing the two dense layers x = x.reshape(x.shape[0], -1) x = self.dense1(x) x = relu(x) x = self.dropout(x) x = self.dense2(x) return x
def __call__(self, x): """ Performs a "forward-pass" of data through the network. This allows us to conveniently initialize a model `m` and then send data through it to be classified by calling `m(x)`. Parameters ---------- x : Union[numpy.ndarray, mygrad.Tensor], shape=(M, ?) A batch of data consisting of M pieces of data, each with a dimentionality of ? (the number of values among all the pixels in a given image). Returns ------- mygrad.Tensor, shape-(M, num_class) The model's prediction for each of the M images in the batch, """ x = relu(self.conv1(x)) x = max_pool(x, (2, 2), 2) x = relu(self.conv2(x)) x = max_pool(x, (2, 2), 2) x = relu(self.dense1(x.reshape(x.shape[0], -1))) return self.dense2(x)
def __call__(self, x): # convol1 = relu(self.conv1(x)) # pool1 = max_pool(convol1, pool=(2,2), stride=2) # convol2 = relu(self.conv2(pool1)) # pool2 = max_pool(convol2, pool=(2,2), stride=2) # flattened = pool2.reshape((len(x), 250)) # den3 = relu(self.dense3(flattened)) # den4 = self.dense4(den3) # return den4 #print(self.conv1(x).shape) step1 = max_pool(self.conv1(x), (2, 2), stride=2) step2 = max_pool(self.conv2(step1), (2, 2), stride=2) flatten = step2.reshape(-1, 500) dense_layers = self.dense2(relu(self.dense1(flatten))) return dense_layers # returns output of dense -> relu -> dense -> relu -> dense -> softmax three layer. pass
def __call__(self, x): """ Performs the full forward pass for the RNN. Note that we only care about the last y - the final classification scores for the full sequence Parameters ---------- x: Union[numpy.ndarray, mygrad.Tensor], shape=(M, N, 50) The word embeddings for the sequence Returns ------- mygrad.Tensor, shape=(M,) The final classification of the sequence """ h = np.zeros((1, self.fc_h2h.weight.shape[0]), dtype=np.float32) for x_t in x: h = relu(self.fc_x2h(x_t[np.newaxis]) + self.fc_h2h(h)) return self.fc_h2y(h)
def __call__(self, x): return self.dense3(relu(self.dense2(relu(self.dense1(x)))))
def __call__(self, X): X = relu(mg.matmul(X, self.w1, True) + self.b1) X = relu(mg.matmul(X, self.w2, True) + self.b2) X = mg.matmul(X, self.w3, True) + self.b3 return mg.nnet.activations.softmax(X, constant=True)