def _run_model_(self, x_test): ''' predicts values for test variables ''' if not self.seperate_regressors: return self.regressor_model.predict(utils.flatten_complex(x_test)) else: temp = [] for reg_model in self.regressor_models: temp.append(reg_model.predict(utils.flatten_complex(x_test))) temp = numpy.stack(temp) return temp.T
def _run_model_(self, x_test): self.network.eval() with torch.no_grad(): fingerprints = torch.tensor(utils.flatten_complex(x_test.values), dtype=torch.float) return self.network(fingerprints)
def _search_for_models_(self, train_x, train_y): self.train_x = utils.flatten_complex(train_x) self.train_y = train_y self.knn = KNeighborsRegressor(n_neighbors=1, algorithm=self.algorithm) self.knn.fit(self.train_x, train_y)
def validate(self, model, validation_loader, loss_func): model.eval() with torch.no_grad(): total_loss = 0 for batch in validation_loader: fingerprints = torch.tensor(utils.flatten_complex( batch['fingerprint']), dtype=torch.float) predicted = model(fingerprints) loss = loss_func(batch['parameters'].float(), predicted) total_loss += loss.item() return total_loss / len(validation_loader)
def _search_for_models_(self, train_x, train_y): ''' Fits the sklearn regressor ''' # splits complex up as most sklrean regressors only work on real values self.train_x = utils.flatten_complex(train_x) self.train_y = train_y # Either trains seperate regressors for each output or trains one regressor for all if supported if not self.seperate_regressors: self.regressor_model = self.regressor_class().fit( self.train_x, train_y) else: self.regressor_models = [ self.regressor_class().fit(self.train_x, train_y[y_col]) for y_col in self.train_y.columns ]
def _search_for_models_(self, train_x, train_y): train_frac = 0.8 # 0,1 mask, 1 for train dataset, 0 for validation dataset rows = get_row_mask(train_frac, len(train_x)) inverse_rows = [not x for x in rows] self.train_x = train_x[rows] self.validation_x = train_x[inverse_rows] self.train_y = train_y[rows] self.validation_y = train_y[inverse_rows] self.train_data_set = FingerprintDataset(self.train_x, self.train_y) self.validation_data_set = FingerprintDataset(self.validation_x, self.validation_y) self.train_loader = DataLoader(self.train_data_set, batch_size=64, shuffle=True) self.validation_loader = DataLoader(self.validation_data_set, batch_size=64, shuffle=False) self.network = n.MyNetwork(self.layers) optimiser = torch.optim.Adam(self.network.parameters(), lr=0.1) scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimiser, verbose=True) loss_func = torch.nn.MSELoss() best_val = 9999999999999999999 best_net = None val_per_epoch = [] early_stopping_after = 50 tolerence = 10 max_epochs = 500 for epoch in range(max_epochs): self.network.train() epoch_loss = 0 for batch in self.train_loader: optimiser.zero_grad() fingerprints = torch.tensor(utils.flatten_complex( batch['fingerprint']), dtype=torch.float) loss = loss_func(self.network(fingerprints), batch['parameters'].float()) loss.backward() optimiser.step() epoch_loss += loss.item() print('Epoch [%d/%d] loss %f' % (epoch, max_epochs, epoch_loss / len(self.train_loader))) val_loss = self.validate(self.network, self.validation_loader, loss_func) print('Epoch [%d/%d] val_loss %f' % (epoch, max_epochs, val_loss)) scheduler.step(val_loss) val_per_epoch.append(val_loss) if val_loss < best_val: best_net = self.network.state_dict() index_x_epochs_ago = len(val_per_epoch) - early_stopping_after if index_x_epochs_ago >= 0 and val_per_epoch[ index_x_epochs_ago] <= val_loss + tolerence: break self.network.load_state_dict(best_net)
def _run_model_(self, x_test): x_test = utils.flatten_complex(x_test) predicted = self.knn.predict(x_test) return predicted