def train_model(train_data, target_path, extracted_pixels_by_mean_shape, mean_shape):
regressors = []
for i in range(Cascades):
curr_regr = Regressor(mean_shape, extracted_pixels_by_mean_shape)
curr_regr.train(train_data)
regressors.append(curr_regr)
print("Finished regressor number 1")
with open(target_path, 'wb') as target:
pickle.dump(regressors, target)
def retrain(self, df, features=[], target=""):
"""
Retrains the object with a new dataframe, features and target
:param df: A pandas DataFrame
:param features: The columns that are selected to be the features of the new regressor
:param target: The column that contains the target of the new regressor
:return: updates the theta value
"""
Regressor.retrain(self, df, features, target)
self.theta = self.__train__()
self.rss = self.__calculate_residual_mean_squared_error__(self.df)
class SurrogateModel(object):
def __init__(self, fitness, configuration, controller):
self.fitness = fitness
self.configuration = configuration
self.classifier = Classifier()
self.regressor = Regressor(controller)
def train(self, pop):
raise NotImplementedError('SurrogateModel is an abstract class, this '
'should not be called.')
def model_particles(self, particles):
MU, S2 = self.regressor.predict(particles)
return self.classifier.predict(particles), MU, S2
def add_training_instance(self, part, code, fitness):
pass
def __getstate__(self):
# Don't pickle fitness and configuration
d = dict(self.__dict__)
del d['fitness']
del d['configuration']
return d
class DummySurrogateModel(SurrogateModel):
## TODO - add dummy regressor/classifier
def __init__(self, configuration, controller, fitness):
super(DummySurrogateModel, self).__init__(configuration,
controller,
fitness)
self.regressor = Regressor(controller, configuration)
self.classifier = Classifier()
def get_regressor(self):
return self.regressor
def get_classifier(self):
return self.classifier
def predict(self, particles):
MU, S2 = self.regressor.predict(particles)
return self.classifier.predict(particles), MU, S2
def train(self, hypercube):
self.was_trained = True
return True
def model_particle(self, particle):
return 0, 0, 0
def contains_training_instance(self, part):
return False
def model_failed(self, part):
return False
def get_state_dictionary(self):
return {}
def set_state_dictionary(self, dict):
pass
def get_copy(self):
model_copy = DummySurrogateModel(self.configuration, self.controller)
return model_copy
def __init__(self, fitness, configuration, controller):
self.fitness = fitness
self.configuration = configuration
self.classifier = Classifier()
self.regressor = Regressor(controller)
def __init__(self, df, features=[], target=""):
Regressor.__init__(self, df, features, target)
self.theta = self.__train__()
self.rmse = self.__calculate_residual_mean_squared_error__(self.df)
self.rss = self.__calculate_residual_sum_of_squares__(df)
def __init__(self, configuration, controller, fitness):
super(DummySurrogateModel, self).__init__(configuration,
controller,
fitness)
self.regressor = Regressor(controller, configuration)
self.classifier = Classifier()
def run_predictions():
data = Data()
data.fetch_data()
total_df = data.preprocess_cases_data(data.df_us_cases)
daily_df = data.daily_data(total_df)
daily_reg = Regressor(daily_df, 7)
pred_path = "data/"
for state in daily_df.columns.tolist():
tempdf = pd.DataFrame(daily_df[state], index=daily_df.index)
state_reg = Regressor(tempdf, 7)
arima_state_data = state_reg.ARIMA(row=state)
arima_state_data.to_csv(pred_path + "daily_{}_ARIMA.csv".format(state))
xg_state_data = state_reg.XGBoost(row=state)
xg_state_data.to_csv(pred_path + "daily_{}_XGBoost.csv".format(state))
lstm_state_data = state_reg.LSTM(row=state, num_estimators=1)
lstm_state_data.to_csv(pred_path + "daily_{}_LSTM.csv".format(state))
total_df_death = data.preprocess_death_data(data.df_us_deaths)
daily_df_death = data.daily_data(total_df_death)
for state in daily_df_death.columns.tolist():
tempdf = pd.DataFrame(daily_df_death[state], index=daily_df_death.index)
death_reg = Regressor(tempdf, 7)
arima_state_death = death_reg.ARIMA(row=state)
arima_state_death.to_csv(pred_path + "death_{}_ARIMA.csv".format(state))
xg_state_death = death_reg.XGBoost(row=state)
xg_state_death.to_csv(pred_path + "death_{}_XGBoost.csv".format(state))
lstm_state_death = death_reg.LSTM(row=state, num_estimators=1)
lstm_state_death.to_csv(pred_path + "death_{}_LSTM.csv".format(state))
