def run_experiment(self):
'''
Run specified experiments
return: dict with metrics
'''
pre = PreProcessing()
ds = DataSource()
met = Metrics()
print('Reading Data')
train_df = ds.read_data(train=True)
test_df = ds.read_data(train=False)
y_test = test_df['y']
print('Preprocessing train data')
X_train, y_train = pre.preprocess(train_df, train=True)
print('Preprocessing test data')
X_test = pre.preprocess(test_df[pre.train_features], train=False)
print('Training model')
models = Experiments().train_model(X_train, y_train)
print('Running metrics')
for model in models.keys():
print(model)
y_pred = models[model].predict(X_test)
print(
met.calculate_classification(model, y_test, pd.Series(y_pred)))
metrics = met.calculate_classification(model, y_test,
pd.Series(y_pred))
pd.DataFrame.from_dict(
metrics, orient='index').to_csv('../output/' + model + '.csv')
return metrics
class ModelTraining():
def __init__(self):
self.data = DataSource()
self.preprocessing = None
def model_training(self):
pre = PreProcessing()
print('Reading data')
df = self.data.read_data(train=True)
print('Starting training')
X_train, y_train = pre.preprocess(df, train=True)
print('Starting training model')
model = CatBoostClassifier()
steps = [('over', SMOTE()), ('model', CatBoostClassifier())]
pipeline = Pipeline(steps=steps)
pipeline.fit(X_train, y_train)
modelo = pipeline['model']
model = {
'model': modelo,
'preprocessing': pre,
'columns': pre.feature_names
}
print(model)
dump(model, '../output/modelo.pkl')
return model
class ModelTraining:
def __init__(self):
self.data = DataSource()
self.preprocessing = None
def model_training(self):
'''
Train the model.
:return: Dict with trained model, preprocessing used and columns used in training
'''
pre = Preprocessing()
print('Loading data')
df = self.data.read_data(etapa_treino=True)
print('Training preprocessing')
X_train, y_train = pre.process(df, etapa_treino=True)
print('Training Model')
model_obj = LinearRegression()
model_obj.fit(X_train, y_train)
model = {
'model_obj': model_obj,
'preprocessing': pre,
'colunas': pre.feature_names
}
print(model)
dump(model, '../output/modelo.pkl')
return model
class ModelTraining:
# começo aqui chamando dataSource e preProcessamento
# como preProc não foi definido então
def __init__(self):
self.data = DataSource()
self.preprocessing = None
def model_training(self):
'''
Train the model.
:return: Dict with trained model, preprocessing used and columns used in training
'''
# chamo o prePocessamento
pre = Preprocessing()
# leio os dados
print('Loading data')
df = self.data.read_data(etapa_treino = True)
# preProcessamento
print('Training preprocessing')
# para treino
X_train, y_train = pre.process(df, etapa_treino = True)
print('Training Model')
# chamo uma regLinear mas já poderia linkar
# com a classe Experiment e retorna o experimento com
# a melhor métrica
model_obj = LinearRegression()
model_obj.fit(X_train, y_train)
# guardando informacoes no dicionario
model = {'model_obj' : model_obj,
'preprocessing' : pre,
'colunas' : pre.feature_names }
print(model)
# salvando modelo treinado com informacoes
dump(model, '../output/modelo.pkl')
# retorna o dicionario de modelo
return model
class ModelTraining:
def __init__(self):
self.data = DataSource()
# os dados são oriundos da classe "DataSource" (arquivo "data_source.py")
self.preprocessing = None
# no início ainda não há o pré-processamento da classe que será salva junto com o modelo
# Criação da função model_training
def model_training(self):
'''
Train the model.
:return: Dict with trained model, preprocessing used and columns used in training
'''
# no momento em que o modelo é treinado, a classe "Preprocessing" é chamada
pre = Preprocessing()
print('Loading data')
# Leitura dos dados na etapa de treino
df = self.data.read_data(etapa_treino=True)
print('Training preprocessing')
# Pré-processamento dos dados de treino ("X_train" e do "y_train")
# os dados de treino vêm junto com a label
X_train, y_train = pre.process(df, etapa_treino=True)
print('Training Model')
# Chamando uma regressão linear
model_obj = LinearRegression()
# Ajustamento do modelo aos dados (para o modelo começar a aprender com os dados)
model_obj.fit(X_train, y_train)
# Retorno da função "model_training" (a função retorna um dicionário)
model = {
'model_obj': model_obj, # objeto do modelo treinado
'preprocessing': pre, # preprocessamento criado
'colunas': pre.feature_names
} # nome das features que foram treinadas junto com o modelo
print(model)
# Salvando o output do modelo
dump(model, '../output/modelo.pkl')
return model
