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