def train_batch(self, batch) -> BatchResult: x, y = batch x = x.to(self.device, dtype=torch.float) # (B,S,V) y = y.to(self.device, dtype=torch.long) # (B,S) seq_len = y.shape[1] # TODO: # Train the RNN model on one batch of data. # - Forward pass # - Calculate total loss over sequence # - Backward pass: truncated back-propagation through time # - Update params # - Calculate number of correct char predictions # ====== YOUR CODE: ====== # Forward pass h = self.hidden y_pred, h = self.model(x, h) # Backward pass self.optimizer.zero_grad() loss = self.loss_fn(torch.transpose(y_pred, 1, 2), y) loss.backward() # Weight updates self.optimizer.step() self.hidden = h.detach() # Calculate accuracy y_pred = torch.argmax(y_pred, dim=-1) num_correct = torch.sum(y_pred == y) # ======================== # Note: scaling num_correct by seq_len because each sample has seq_len # different predictions. return BatchResult(loss.item(), num_correct.item() / seq_len)
def test_batch(self, batch) -> BatchResult: x, y = batch x = x.to(self.device, dtype=torch.float) # (B,S,V) y = y.to(self.device, dtype=torch.long) # (B,S) seq_len = y.shape[1] with torch.no_grad(): # TODO: # Evaluate the RNN model on one batch of data. # - Forward pass # - Loss calculation # - Calculate number of correct predictions # ====== YOUR CODE: ====== self.model.to(self.device) y_pred, self.hidden = self.model(x, self.hidden) y_pred_fixed = torch.transpose(y_pred, 1, 2) loss = self.loss_fn(y_pred_fixed, y) # Prevent gradient vanishing or exploding self.hidden.detach_() self.hidden.requires_grad = False num_correct = 0 for i in range(y_pred_fixed.shape[2]): num_correct = (num_correct + 1) if (torch.argmax( y_pred_fixed[0, :, i]) == y[0, i]) else num_correct # ======================== return BatchResult(loss.item(), num_correct / seq_len)
def train_batch(self, batch) -> BatchResult: x, y = batch x = x.to(self.device, dtype=torch.float) # (B,S,V) y = y.to(self.device, dtype=torch.long) # (B,S) seq_len = y.shape[1] # TODO: # Train the RNN model on one batch of data. # - Forward pass # - Calculate total loss over sequence # - Backward pass: truncated back-propagation through time # - Update params # - Calculate number of correct char predictions # ====== YOUR CODE: ====== # raise NotImplementedError() # the regular order of train y_pred, self.hidden = self.model(x, self.hidden) #truncated back-propagation through time self.hidden.detach_() y_pred = y_pred.transpose(1, 2) loss = self.loss_fn(y_pred, y) self.optimizer.zero_grad() loss.backward() self.optimizer.step() #calculating what we need y_pred = y_pred.argmax(dim=1) #[B, in_dim, S]-> [B, S] num_correct = torch.sum((y == y_pred)) # ======================== # Note: scaling num_correct by seq_len because each sample has seq_len # different predictions. return BatchResult(loss.item(), num_correct.item() / seq_len)
def test_batch( self, batch, **kw, ) -> BatchResult: if 'train_time_testing' in list(kw): x, y, idx = batch else: x, y, = batch x = x.to( self.device, dtype=torch.float, ) y = y.to( self.device, dtype=torch.float, ) with torch.no_grad(): if self.backbone is not None: x = self.backbone(x) y_hat = self.model(x, ) if 'train_time_testing' in list(kw): self.model.test_labels[idx] = torch.argmax( y_hat.clone().detach().cpu(), -1).float() loss = self.loss_fn( y_hat, y, ) y_pred = torch.argmax(y_hat, dim=-1) num_correct = torch.sum(y == y_pred) return BatchResult(loss.item(), num_correct.item() / len(y))
def test_batch(self, batch) -> BatchResult: x, y = batch x = x.to(self.device, dtype=torch.float) # (B,S,V) y = y.to(self.device, dtype=torch.long) # (B,S) seq_len = y.shape[1] with torch.no_grad(): # TODO: # Evaluate the RNN model on one batch of data. # - Forward pass # - Loss calculation # - Calculate number of correct predictions # ====== YOUR CODE: ====== #raise NotImplementedError() # the regular order of train y_pred, self.hidden = self.model(x, self.hidden) y_pred = y_pred.transpose(1, 2) loss = self.loss_fn(y_pred, y) #calculating what we need y_pred = y_pred.argmax(dim=1) #[B, in_dim, S]-> [B, S] num_correct = torch.sum((y == y_pred)) # ======================== return BatchResult(loss.item(), num_correct.item() / seq_len)
def train_batch(self, batch) -> BatchResult: X, y = batch if self.device: X = X.to(self.device) y = y.to(self.device) # TODO: Train the PyTorch model on one batch of data. # - Forward pass # - Backward pass # - Optimize params # - Calculate number of correct predictions # ====== YOUR CODE: ====== y_pred = self.model(X) loss = self.loss_fn(y_pred, y) self.optimizer.zero_grad() loss.backward() self.optimizer.step() _, y_pred_indices = torch.max(y_pred, dim=1) num_incorrect = len(torch.nonzero(y_pred_indices - y)) num_correct = X.shape[0] - num_incorrect # ======================== return BatchResult(loss, num_correct)
def test_batch(self, batch) -> BatchResult: x, y = batch x = x.to(self.device, dtype=torch.float) # (B,S,V) y = y.to(self.device, dtype=torch.long) # (B,S) seq_len = y.shape[1] with torch.no_grad(): # TODO: # Evaluate the RNN model on one batch of data. # - Forward pass # - Loss calculation # - Calculate number of correct predictions # ====== YOUR CODE: ====== h = self.hidden # forward pass y_pred, h = self.model(x, h) # loss function loss = self.loss_fn(torch.transpose(y_pred, 1, 2), y) # Calculate accuracy y_pred = torch.argmax(y_pred, dim=-1) num_correct = torch.sum(y_pred == y) # ======================== return BatchResult(loss.item(), num_correct.item() / seq_len)
def train_batch(self, batch) -> BatchResult: x, y = batch x = x.to(self.device, dtype=torch.float) # (B,S,V) y = y.to(self.device, dtype=torch.long) # (B,S) seq_len = y.shape[1] # TODO: # Train the RNN model on one batch of data. # - Forward pass # - Calculate total loss over sequence # - Backward pass: truncated back-propagation through time # - Update params # - Calculate number of correct char predictions # ====== YOUR CODE: ====== self.optimizer.zero_grad() self.h.detach_() y_output, self.h = self.model(x, self.h) loss = self.loss_fn(y_output.transpose(1, 2), y) loss.backward() self.optimizer.step() num_correct = (y == torch.argmax(y_output, 2)).sum() # raise NotImplementedError() # ======================== # Note: scaling num_correct by seq_len because each sample has seq_len # different predictions. return BatchResult(loss.item(), num_correct.item() / seq_len)
def test_batch(self, batch, batch_idx=None, epoch_num=None, dl=None) -> BatchResult: dimension = batch.shape[1] - 1 # We train the autoencoder in an unsupervised fashion. Therefore, there are no labels. if self.autoencoder_training: X = batch y = X else: y = batch[:, dimension].unsqueeze(-1).long() X = batch[:, list(range(dimension))] if self.device: X = X.to(self.device) y = y.to(self.device) with torch.no_grad(): if self.autoencoder_training: enc = self.model.encoder(X) output = self.model.decoder(enc) loss1 = self.loss_fn.forward(output, y) loss2 = self.loss_fn2.forward(enc.squeeze(-1), target(enc.squeeze(-1))) loss = loss1 + loss2 num_correct = 0 else: out = self.model.forward(X) loss = self.loss_fn.forward(out, y) num_correct = torch.sum(torch.max(out, dim=1)[1] - y == 0) # ======================== return BatchResult(loss, num_correct)
def test_batch(self, batch) -> BatchResult: x, _ = batch x = x.to(self.device) # Image batch (N,C,H,W) with torch.no_grad(): # TODO: Evaluate a VAE on one batch. # ====== YOUR CODE: ====== N = x.shape[0] self.optimizer.zero_grad() for i in range(N): if i == 0: image = x[i, :, :, :].unsqueeze(0) image_rec, mu, log_sigma2 = self.model(image) xr = image_rec else: image = x[i, :, :, :].unsqueeze(0) image_rec, curr_mu, curr_log_sigma2 = self.model(image) xr = torch.cat([xr, image_rec], dim=0) mu = torch.cat([mu, curr_mu], dim=0) log_sigma2 = torch.cat([log_sigma2, curr_log_sigma2], dim=0) loss, data_loss, _ = self.loss_fn(x, xr, mu, log_sigma2) # ======================== return BatchResult(loss.item(), 1/data_loss.item())
def train_batch(self, batch) -> BatchResult: X, y = batch # TODO: Train the Block model on one batch of data. # - Forward pass # - Backward pass # - Optimize params # - Calculate number of correct predictions # ====== YOUR CODE: ====== #raise NotImplementedError() # ======================== N = X.shape[0] x = X.reshape(N, -1) class_scores = self.model(x) loss = self.loss_fn(class_scores, y).numpy() self.optimizer.zero_grad() dout = self.loss_fn.backward() self.model.backward(dout) self.optimizer.step() y_pred = torch.argmax(class_scores, dim=1) num_correct = int(torch.sum(y == y_pred).item()) #num_correct = torch.sum(y == y_pred).numpy() return BatchResult(loss, num_correct)
def train_batch(self, batch) -> BatchResult: X, y = batch if self.device: X = X.to(self.device) y = y.to(self.device) # TODO: Train the PyTorch model on one batch of data. # - Forward pass # - Backward pass # - Optimize params # - Calculate number of correct predictions # ====== YOUR CODE: ====== # Forward pass out = self.model(X) # Compute loss loss = self.loss_fn(out, y) # Backward pass self.optimizer.zero_grad() loss.backward() # Optimization step self.optimizer.step() loss = loss.item() num_correct = (torch.argmax(out, dim=1) == y).sum().item() # ======================== return BatchResult(loss, num_correct)
def train_batch(self, batch) -> BatchResult: x, _ = batch x = x.to(self.device) # Image batch (N,C,H,W) # TODO: Train a VAE on one batch. # ====== YOUR CODE: ====== y, mu, log_sigma2 = self.model(x) loss, data_loss, kldiv_loss = self.loss_fn(x, y, mu, log_sigma2) self.optimizer.zero_grad() loss.backward() self.optimizer.step() y, mu, log_sigma2 = self.model(x) loss, data_loss, kldiv_loss = self.loss_fn(x, y, mu, log_sigma2) # if self.hidden_state is None: # out, hidden_state = self.model(x) # else: # out, hidden_state = self.model(x, self.hidden_state.detach()) # loss = self.loss_fn(out.reshape(batch_size*seq_len, out.shape[-1]), y.reshape(batch_size*seq_len)) # self.optimizer.zero_grad() # loss.backward() # self.optimizer.step() # if self.hidden_state is None: # out, _ = self.model(x) # else: # out, _ = self.model(x, self.hidden_state.detach()) # self.hidden_state = hidden_state # scores, indices = torch.max(out.reshape(batch_size*seq_len, out.shape[-1]), dim=len(out.shape)-2) # num_correct = (indices.reshape(y.shape) == y).sum() # ======================== return BatchResult(loss.item(), 1 / data_loss.item())
def train_batch(self, batch) -> BatchResult: X, y = batch if self.device: X = X.to(self.device) y = y.to(self.device) # TODO: Train the PyTorch model on one batch of data. # - Forward pass # - Backward pass # - Optimize params # - Calculate number of correct predictions # ====== YOUR CODE: ====== y_pred = self.model.forward(X) y_loss = self.loss_fn.forward(y_pred, y) self.optimizer.zero_grad() torch.autograd.backward(y_loss) _, pred_classes = torch.max(y_pred, dim=1) correct = torch.sum(pred_classes == y) self.optimizer.step() loss = y_loss.item() num_correct = correct.item() # ======================== return BatchResult(loss, num_correct)
def test_batch(self, batch) -> BatchResult: x, y = batch x = x.to(self.device, dtype=torch.float) # (B,S,V) y = y.to(self.device, dtype=torch.long) # (B,S) seq_len = y.shape[1] batch_size = y.shape[0] with torch.no_grad(): # TODO: # Evaluate the RNN model on one batch of data. # - Forward pass # - Loss calculation # - Calculate number of correct predictions # ====== YOUR CODE: ====== out, self.hidden_state = self.model(x, self.hidden_state) loss = self.loss_fn( out.reshape(batch_size * seq_len, out.shape[-1]), y.reshape(batch_size * seq_len)) scores, indices = torch.max(out.reshape(batch_size * seq_len, out.shape[-1]), dim=len(out.shape) - 2) num_correct = (indices.reshape(y.shape) == y).sum() # ======================== return BatchResult(loss.item(), num_correct.item() / seq_len)
def train_batch(self, batch) -> BatchResult: x, y = batch x = x.to(self.device, dtype=torch.float) # (B,S,V) y = y.to(self.device, dtype=torch.long) # (B,S) seq_len = y.shape[1] batch_size = y.shape[0] # TODO: # Train the RNN model on one batch of data. # - Forward pass # - Calculate total loss over sequence # - Backward pass: truncated back-propagation through time # - Update params # - Calculate number of correct char predictions # ====== YOUR CODE: ====== # print("first") # if self.hidden_state is None: # out, hidden_state = self.model(x) # else: # out, hidden_state = self.model(x, self.hidden_state.detach()) # self.hidden_state = hidden_state # loss = self.loss_fn(out.squeeze(0), y.squeeze(0)) # # self.optimizer.zero_grad() # # if is_first: # # loss.backward(retain_graph=True) # # else: # loss.backward() # self.optimizer.step() # # out, _ = self.model(x, hidden_state) # score, indices = torch.max(out.squeeze(0), dim=1) # num_correct = (indices == y).sum() # if num_correct.item() / seq_len > 0.9: # print("indices:", indices) # print("y:", indices) # print("last") if self.hidden_state is None: out, hidden_state = self.model(x) else: out, hidden_state = self.model(x, self.hidden_state.detach()) loss = self.loss_fn(out.reshape(batch_size * seq_len, out.shape[-1]), y.reshape(batch_size * seq_len)) self.optimizer.zero_grad() loss.backward() self.optimizer.step() if self.hidden_state is None: out, _ = self.model(x) else: out, _ = self.model(x, self.hidden_state.detach()) self.hidden_state = hidden_state scores, indices = torch.max(out.reshape(batch_size * seq_len, out.shape[-1]), dim=len(out.shape) - 2) num_correct = (indices.reshape(y.shape) == y).sum() # ======================== # Note: scaling num_correct by seq_len because each sample has seq_len # different predictions. return BatchResult(loss.item(), num_correct.item() / seq_len)
def train_batch(self, batch) -> BatchResult: X, y = batch if self.device: X = X.to(self.device) y = y.to(self.device) # TODO: Train the PyTorch model on one batch of data. # - Forward pass # - Backward pass # - Optimize params # - Calculate number of correct predictions # ====== YOUR CODE: ====== #raise NotImplementedError() self.optimizer.zero_grad() res = self.model(X) loss = self.loss_fn(res, y) # if self.device: # res = res.to(self.device) # loss = loss.to(self.device) loss.backward() self.optimizer.step() res = res.argmax(1) num_correct = (res == y).sum() # ======================== return BatchResult(loss, num_correct)
def test_batch(self, batch) -> BatchResult: x, y = batch x = x.to(self.device, dtype=torch.float) # (B,S,V) y = y.to(self.device, dtype=torch.long) # (B,S) seq_len = y.shape[1] with torch.no_grad(): # TODO: # Evaluate the RNN model on one batch of data. # - Forward pass # - Loss calculation # - Calculate number of correct predictions # ====== YOUR CODE: ====== output, hidden = self.model.forward(x, self.hidden) self.hidden = hidden num_correct = 0 for i in range(seq_len): y_sequence = y[:, i] scores_sequence = output[:, i, :].to(self.device, dtype=torch.float) if i == 0: loss = self.loss_fn(scores_sequence, y_sequence) else: loss += self.loss_fn(scores_sequence, y_sequence) pred = scores_sequence.argmax(dim=1) num_correct += (y_sequence == pred).sum() # ======================== return BatchResult(loss.item(), num_correct.item() / seq_len)
def train_batch(self, batch) -> BatchResult: x, _ = batch x = x.to(self.device) # Image batch (N,C,H,W) # TODO: Train a VAE on one batch. # ====== YOUR CODE: ====== raise NotImplementedError() # ======================== return BatchResult(loss.item(), 1 / data_loss.item())
def test_batch(self, batch) -> BatchResult: x, _ = batch x = x.to(self.device) # Image batch (N,C,H,W) with torch.no_grad(): # TODO: Evaluate a VAE on one batch. # ====== YOUR CODE: ====== raise NotImplementedError() # ======================== return BatchResult(loss.item(), 1 / data_loss.item())
def test_batch(self, batch) -> BatchResult: X, y = batch # TODO: Evaluate the Block model on one batch of data. # - Forward pass # - Calculate number of correct predictions # ====== YOUR CODE: ====== raise NotImplementedError() # ======================== return BatchResult(loss, num_correct)
def test_batch(self, batch) -> BatchResult: x, _ = batch x = x.to(self.device) # Image batch (N,C,H,W) with torch.no_grad(): # TODO: Evaluate a VAE on one batch. # ====== YOUR CODE: ====== y, mu, log_sigma2 = self.model(x) loss, data_loss, kldiv_loss = self.loss_fn(x, y, mu, log_sigma2) # ======================== return BatchResult(loss.item(), 1 / data_loss.item())
def test_batch(self, batch) -> BatchResult: X, y = batch # TODO: Evaluate the Layer model on one batch of data. # ====== YOUR CODE: ====== X = X.view(X.shape[0], -1) y_pred = self.model(X) loss = self.loss_fn(y_pred, y) y_pred = y_pred.argmax(dim=1) num_correct = int((y == y_pred).sum()) # ======================== return BatchResult(loss, num_correct)
def test_batch(self, batch) -> BatchResult: x, _ = batch x = x.to(self.device) # Image batch (N,C,H,W) with torch.no_grad(): # TODO: Evaluate a VAE on one batch. # ====== YOUR CODE: ====== xr, z_mu, z_log_sigma2 = self.model(x) loss, data_loss, _ = self.loss_fn(x, xr, z_mu, z_log_sigma2) #raise NotImplementedError() # ======================== return BatchResult(loss.item(), 1 / data_loss.item())
def test_batch(self, batch) -> BatchResult: X, y = batch # TODO: Evaluate the Block model on one batch of data. # - Forward pass # - Calculate number of correct predictions # ====== YOUR CODE: ====== out = self.model.forward(X) loss = self.loss_fn(out, y).item() num_correct = (torch.argmax(out, dim=1) == y).sum().item() # ======================== return BatchResult(loss, num_correct)
def test_batch(self, batch) -> BatchResult: X, y = batch # TODO: Evaluate the Block model on one batch of data. # - Forward pass # - Calculate number of correct predictions # ====== YOUR CODE: ====== y_prediction = self.model(X) loss = self.loss_fn(y_prediction, y) num_correct = torch.sum( y.eq(torch.argmax(y_prediction, dim=1)).float()).item() # ======================== return BatchResult(loss, num_correct)
def test_batch(self, batch) -> BatchResult: X, y = batch # TODO: Evaluate the Block model on one batch of data. # - Forward pass # - Calculate number of correct predictions # ====== YOUR CODE: ====== x_scores = self.model(X) loss = self.loss_fn(x_scores, y).item() y_hat = x_scores.argmax(dim=1) num_correct = int(sum(1 * (y_hat == y))) # ======================== return BatchResult(loss, num_correct)
def test_batch(self, batch) -> BatchResult: X, y = batch # TODO: Evaluate the Block model on one batch of data. # - Forward pass # - Calculate number of correct predictions # ====== YOUR CODE: ====== self.optimizer.zero_grad() class_scores = self.model.forward(X) loss = self.loss_fn.forward(class_scores, y=y) pred = class_scores.argmax(dim=1) num_correct = (y == pred).sum() # ======================== return BatchResult(loss, num_correct)
def test_batch(self, batch) -> BatchResult: X, y = batch if self.device: X = X.to(self.device) y = y.to(self.device) with torch.no_grad(): # TODO: Evaluate the PyTorch model on one batch of data. # - Forward pass # - Calculate number of correct predictions # ====== YOUR CODE: ====== raise NotImplementedError() # ======================== return BatchResult(loss, num_correct)
def train_batch(self, batch) -> BatchResult: X, y = batch if self.device: X = X.to(self.device) y = y.to(self.device) # TODO: Train the PyTorch model on one batch of data. # - Forward pass # - Backward pass # - Optimize params # - Calculate number of correct predictions # ====== YOUR CODE: ====== raise NotImplementedError() # ======================== return BatchResult(loss, num_correct)