def __init__(self, regiao):
self.regiao = str(regiao)
self.control_estado = ControlEstado(
) # Instancia a classe de controle dos dados UF
self.control_municipio = ControlMunicipio(
) # Instancia a classe de controle dos dados Municipais
self.control_analise = ControlAnalise(
) # Instancia a classe de controle de análise exploratória(UF)
self.control_regressor = ControlRegressor()
self.df = pd.DataFrame()
self.df_balanced = pd.DataFrame()
self.df_metrics = pd.DataFrame()
self.target = int
self.dct_baseline = dict({})
self.dct_baseline_sc = dict({})
self.dct_balanced_base = dict({})
self.dct_balanced_base_sc = dict({})
self.dct_basetunned = dict({})
self.dct_basetunned_sc = dict({})
self.dct_balanced_tunned = dict({})
self.dct_balanced_tunned_sc = dict({})
self.dct_compare = dict({})
self.modelo = tuple()
if self.regiao == 'estadual':
self.control = self.control_estado
elif self.regiao == 'municipio':
self.control = self.control_municipio
def __init__(self, X=np.array([]), y=np.array([]), ploter=list([])):
self.X = X
self.y = y
self.ploter = ploter
self.control_validator = ControlValidator()
self.control_analise = ControlAnalise()
class ControlValidator(object):
def __init__(self):
self.validator = Validator()
self.control_analise = ControlAnalise()
self.resultados = []
def validate(self, X, y, regressor):
# Retorna o array com os resutltadso Score do modelo específico
return self.validator.validate_models(X, y, regressor, self.resultados)
def compare(self, results, lst_models):
# self.validation = self.control_regressor.get_validation(
# self.X, self.y, test_size, validation, base, plt_text, balance, kwargs) # Invoca a função de validação StratifiedKFold
# Invoca a função de comparação dos resultados de 30 testes cada modelo
result_wilcox, result_fried, models_par, ranks, names, cds, average_ranks = self.validator.compare_results(
results, lst_models)
self.control_analise.print_conclusao(
result_wilcox, result_fried, ranks, models_par, names, cds,
average_ranks,
lst_models) # Imprime a conclusão das comparações de validação
return ranks, names
def __init__(self):
self.regressor = Regressor()
self.validator = Validator()
self.control_analise = ControlAnalise()
self.control_validator = ControlValidator()
self.lst_modelo = [
'arvore', 'linear_poly', 'rede_neural', 'support_vector'
]
class Inscricao(object):
def __init__(self, regiao):
self.regiao = str(regiao)
self.control_estado = ControlEstado(
) # Instancia a classe de controle dos dados UF
self.control_municipio = ControlMunicipio(
) # Instancia a classe de controle dos dados Municipais
self.control_analise = ControlAnalise(
) # Instancia a classe de controle de análise exploratória(UF)
self.control_regressor = ControlRegressor()
self.df = pd.DataFrame()
self.df_balanced = pd.DataFrame()
self.df_metrics = pd.DataFrame()
self.target = int
self.dct_baseline = dict({})
self.dct_baseline_sc = dict({})
self.dct_balanced_base = dict({})
self.dct_balanced_base_sc = dict({})
self.dct_basetunned = dict({})
self.dct_basetunned_sc = dict({})
self.dct_balanced_tunned = dict({})
self.dct_balanced_tunned_sc = dict({})
self.dct_compare = dict({})
self.modelo = tuple()
if self.regiao == 'estadual':
self.control = self.control_estado
elif self.regiao == 'municipio':
self.control = self.control_municipio
def set_dataframe(self):
self.df = self.control.get_raw() # Invoca a função de leitura dos CSVs
## Recebe o DataFrame com os dados originais
self.df_balanced = self.control.balance_data(
self.df) # Invoca a função enviando o DataFrame original
## Recebe o DataFrame com os dados originais
self.target = self.control.set_target(self.df) # Seleciona o target
return
def set_predicted(self, predicted=False):
self.df_balanced = self.control.balance_data(
) # Invoca a função enviando o DataFrame original
return
def set_metrics(self,
test_size=0.15,
random_state=0,
base=False,
balanced=False,
scaled=False,
balance=[],
baseline=[],
scale=[],
plot=True,
validation=False):
Dataframe = [self.df, self.df_balanced]
dct_metrics = self.control.pre_process(Dataframe, test_size,
random_state, base, balanced,
scaled, balance, baseline,
scale, plot, validation)
if validation:
self.modelo = dct_metrics
return self.modelo
if len(balance) > 0:
self.dct_compare = dct_metrics
return
if base:
if balanced:
if scaled:
self.dct_balanced_base_sc = dct_metrics
return
self.dct_balanced_base = dct_metrics
return
else:
if scaled:
self.dct_baseline_sc = dct_metrics
return
self.dct_baseline = dct_metrics
return
else:
if balanced:
if scaled:
self.dct_balanced_tunned_sc = dct_metrics
return
self.dct_balanced_tunned = dct_metrics
return
else:
if scaled:
self.dct_basetunned_sc = dct_metrics
return
self.dct_basetunned = dct_metrics
return
return ## Recebe o DataFrame com os dados originais
def set_predict(self, modelo, balanced=False):
previsores = self.control.get_previsores(
self.df_balanced, balanced,
modelo) # Invoca a função enviando o DataFrame pré-processado
## Recebe os previsores de 2019
previsoes = self.control_regressor.get_predict(
previsores, modelo
) # Invoca a função enviando os previsores e o modelo selecionado
return previsoes
self.df_balanced = self.control.set_previsoes(
self.df_balanced, 'ano', 2019, self.control.lst_targets[0],
previsoes
) # Insere as previsões no DataFrame enviando o DataFrame, Coluna Index, Valor Query, Coluna Target e Previsões
## Recebe o DataFrame com as previsões
return
def view_metrics(self):
"""
Cria a estrutura do DataFrame de métricas para comparação"""
self.df_metrics['model'] = [
model for model in list(
['arvore', 'linear_poly', 'rede_neural', 'support_vector'])
]
self.df_metrics['baseline(mae)'] = [
model[1][1] for model in list(self.dct_baseline.items())
]
self.df_metrics['baseline_sc(mae)'] = [
model[1][1] for model in list(self.dct_baseline_sc.items())
]
self.df_metrics['balanced(mae)'] = [
model[1][1] for model in list(self.dct_balanced_base.items())
]
self.df_metrics['balanced_sc(mae)'] = [
model[1][1] for model in list(self.dct_balanced_base_sc.items())
]
self.df_metrics['tunned(mae)'] = [
model[1][1] for model in list(self.dct_basetunned.items())
]
self.df_metrics['tunned_sc(mae)'] = [
model[1][1] for model in list(self.dct_basetunned_sc.items())
]
self.df_metrics['balanced_tunned(mae)'] = [
model[1][1] for model in list(self.dct_balanced_tunned.items())
]
self.df_metrics['balanced_tunned_sc(mae)'] = [
model[1][1] for model in list(self.dct_balanced_tunned_sc.items())
]
self.df_metrics['compare(mae)'] = [
model[1][1] for model in list(self.dct_compare.items())
]
self.df_metrics['baseline(score)'] = [
model[1][0] for model in list(self.dct_baseline.items())
]
self.df_metrics['baseline_sc(score)'] = [
model[1][0] for model in list(self.dct_baseline_sc.items())
]
self.df_metrics['balanced(score)'] = [
model[1][0] for model in list(self.dct_balanced_base.items())
]
self.df_metrics['balanced_sc(score)'] = [
model[1][0] for model in list(self.dct_balanced_base_sc.items())
]
self.df_metrics['tunned(score)'] = [
model[1][0] for model in list(self.dct_basetunned.items())
]
self.df_metrics['tunned_sc(score)'] = [
model[1][0] for model in list(self.dct_basetunned_sc.items())
]
self.df_metrics['balanced_tunned(score)'] = [
model[1][0] for model in list(self.dct_balanced_tunned.items())
]
self.df_metrics['balanced_tunned_sc(score)'] = [
model[1][0] for model in list(self.dct_balanced_tunned_sc.items())
]
self.df_metrics['compare(score)'] = [
model[1][0] for model in list(self.dct_compare.items())
]
return
def view_plot(self, data, predicted=False):
if predicted or data == 'estrutura':
df = self.df_balanced
else:
df = self.df
if data == 'inscricao':
self.control_analise.inscritos_ano(
df, predicted
) # Plota distribuição de Inscrições no ENEM por ANO(2010 a 2019)/UF
return
if data == 'estrutura':
self.control_analise.estrutura_ano(
df, predicted
) # Plota distribuição da estrutura educacional ANO(2010 a 2019)/UF
return
print(
"Por getileza, especifique os dados que deseja plotar ('inscricao' ou 'estrutura')"
)
return
class ControlRegressor(object):
def __init__(self):
self.regressor = Regressor()
self.validator = Validator()
self.control_analise = ControlAnalise()
self.control_validator = ControlValidator()
self.lst_modelo = [
'arvore', 'linear_poly', 'rede_neural', 'support_vector'
]
def set_kwargs(self, base, baseline):
kwargs = []
if len(baseline) > 0:
base = False
kwargs.append({
'tree': {
'max_depth': 15,
'criterion': 'friedman_mse'
},
'boost': {
'n_estimators': 1000,
'learning_rate': .00001
},
'tunned': {
'test': '0'
}
}) if base is False else kwargs.append({'tree': {}})
kwargs.append({
'fit_intercept': False,
'n_jobs': -1,
'normalize': True
}) if base is False else kwargs.append({})
kwargs.append({
'max_iter': 3000,
'early_stopping': True,
'activation': 'tanh',
'solver': 'lbfgs',
'alpha': 0.0005,
'tol': 1e-5,
'shuffle': True,
'learning_rate': 'adaptive'
}) if base is False else kwargs.append({})
kwargs.append({
'max_iter': 10000,
'kernel': 'rbf',
'tol': 7e-6,
'C': 3.7,
'epsilon': 0.03,
'degree': 1,
'gamma': 'scale',
'coef0': 0
}) if base is False else kwargs.append({})
for dct in list(baseline):
if dct in list(baseline):
kwargs[dct] = {'tree': {}} if dct == 0 else {}
return kwargs
#len('boost' in {'tree':{'max_depth':15, 'criterion':'friedman_mse'},'boost':{'n_estimators':250, 'learning_rate':.1},'tunned':{}})
def train_test(self, X, y, test_size, random_state):
# Divide a base em treino e teste com valor de 15% para teste (BASE DE DADOS PEQUENA)
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=test_size, random_state=random_state)
return X_train, X_test, y_train, y_test
def get_metrics(self,
X,
y,
pre,
random_state,
base,
scaled,
plt_text,
config,
kwargs,
validation,
plot,
modelo=None,
selection=False) -> np.array:
dct_text = None
def get_args(X, y, i, pre, config, scaled, kwargs):
pre = pre if i not in config else config[i]['pre']
kwargs = kwargs[i] if i not in config else config[i]['kwargs'][i]
scaled = scaled if i not in config else config[i]['scaled']
X = X if i not in config else config[i]['X']
y = y if i not in config else config[i]['y']
return X, y, pre, kwargs, scaled
if plot:
dct_text = self.control_analise.set_plt_text(plt_text)
if modelo == None or modelo == 'arvore':
X_ad, y_ad, pre_ad, kwargs_ad, scaled_ad = get_args(
X, y, 0, pre, config, scaled, kwargs)
X_ad = (pre_ad['scaler'][0][0], pre_ad['scaler'][0][1],
X_ad[2]) if scaled_ad else X_ad
y_ad = pre_ad['scaler'][1] if scaled_ad else y_ad
kwargs_ad['tree']['random_state'] = random_state
if modelo == 'arvore' and validation:
X, y = np.vstack((X_ad[0], X_ad[1])), np.vstack(
(y_ad[0], y_ad[1]))
# Retorna array com os 30 resultados
return self.regressor.treinar_arvore(X[:, 1:], y, pre_ad,
scaled_ad, plot, dct_text,
validation, kwargs_ad)
# Invoca a função de treinamento do modelo passando os hiperparâmetros e valores de treino(X) e teste(y)
# Regressão com Árvore de Decisão
feat_importances_arvore, score_arvore, mae_arvore, modelo_arvore = self.regressor.treinar_arvore(
X_ad, y_ad, pre_ad, scaled_ad, plot, dct_text, validation,
kwargs_ad)
if modelo != None and selection is True:
return (pre['scaler'][2], pre['scaler'][3],
feat_importances_arvore, score_arvore, mae_arvore,
modelo_arvore)
if modelo == None or modelo == 'linear_poly':
X_lp, y_lp, pre_lp, kwargs_lp, scaled_lp = get_args(
X, y, 1, pre, config, scaled, kwargs)
X_lp = (
pre_lp['poly'][1].transform(
pre_lp['scaler'][0][0]), #pre_lp['poly'][0][0][:,1:]
pre_lp['poly'][1].transform(
pre_lp['scaler'][0][1]), #pre_lp['poly'][0][1][:,1:]
X_lp[2]) if scaled_lp else (pre_lp['poly'][0][0],
pre_lp['poly'][0][1], X_lp[2])
y_lp = pre_lp['scaler'][1] if scaled_lp else y_lp
if modelo == 'linear_poly' and validation:
X, y = np.vstack((X_lp[0], X_lp[1])), np.vstack(
(y_lp[0], y_lp[1]))
# Retorna array com os 30 resultados
return self.regressor.treinar_linear_poly(
X, y, pre_lp, scaled_lp, plot, dct_text, validation,
kwargs_lp)
# Invoca a função de treinamento do modelo passando os hiperparâmetros e valores de treino(X) e teste(y)
# Regressão Linear(Polinomial)
score_poly, mae_poly, modelo_poly = self.regressor.treinar_linear_poly(
X_lp, y_lp, pre_lp, scaled_lp, plot, dct_text, validation,
kwargs_lp)
if modelo != None and selection is True:
return (pre['scaler'][2], pre['scaler'][3], score_poly,
mae_poly, modelo_poly)
if modelo == None or modelo == 'rede_neural':
X_rn, y_rn, pre_rn, kwargs_rn, scaled_rn = get_args(
X, y, 2, pre, config, scaled, kwargs)
X_rn = (pre_rn['scaler'][0][0], pre_rn['scaler'][0][1], X_rn[2])
y_rn = pre_rn['scaler'][1]
node = int((X_rn[2].shape[1]) / 2) + 1
kwargs_rn['hidden_layer_sizes'] = (node, node)
# kwargs_rn['random_state'] = random_state
# Define a quantidade de camadas ocultas
# Invoca a função de treinamento do modelo passando os hiperparâmetros e valores de treino(X) e teste(y)
# Regressão com Rede neural(MPL)
if modelo == 'rede_neural' and validation is True:
X, y = np.vstack((X_rn[0], X_rn[1])), np.vstack(
(y_rn[0], y_rn[1]))
# Retorna array com os 30 resultados
return self.regressor.treinar_redeneural(
X[:, 1:], y, pre_rn, scaled_rn, plot, dct_text, validation,
kwargs_rn)
score_mpl, mae_mpl, modelo_mpl = self.regressor.treinar_redeneural(
X_rn, y_rn, pre_rn, scaled_rn, plot, dct_text, validation,
kwargs_rn)
if modelo != None and selection is True:
return (pre['scaler'][2], pre['scaler'][3], score_mpl, mae_mpl,
modelo_mpl)
if modelo == None or modelo == 'support_vector':
X_sv, y_sv, pre_sv, kwargs_sv, scaled_sv = get_args(
X, y, 3, pre, config, scaled, kwargs)
X_sv = (pre_sv['scaler'][0][0], pre_sv['scaler'][0][1], X_sv[2])
y_sv = pre_sv['scaler'][1]
if modelo == 'support_vector' and validation is True:
X, y = np.vstack((X_sv[0], X_sv[1])), np.vstack(
(y_sv[0], y_sv[1]))
# Retorna array com os 30 resultados
return self.regressor.treinar_svr(X, y, pre_sv, scaled_sv,
plot, dct_text, validation,
kwargs_sv)
# Invoca a função de treinamento do modelo passando os hiperparâmetros e valores de treino(X) e teste(y)
# Regressão Linear(Polinomial)
score_svr, mae_svr, modelo_svr = self.regressor.treinar_svr(
X_sv, y_sv, pre_sv, scaled_sv, plot, dct_text, validation,
kwargs_sv)
if modelo != None and selection is True:
return (pre['scaler'][2], pre['scaler'][3], score_svr, mae_svr,
modelo_svr)
dict_base_line = {
'arvore': (score_arvore, mae_arvore),
'linear_poly': (score_poly, mae_poly),
'rede_neural': (score_mpl, mae_mpl),
'support_vector': (score_svr, mae_svr)
}
return dict_base_line
def get_predict(self, X, modelo) -> np.array:
if 'StandardScaler' in str(modelo[0]):
# Faz as predições do número de inscritos no ENEM 2019
previsoes = modelo[-1].predict(modelo[1].transform(X))
previsoes = modelo[1].inverse_transform(previsoes)
else:
previsoes = modelo[-1].predict(X)
return previsoes
def get_validation(self, X, y, pre, random_state, base, scaled, plt_text,
config, kwargs, validation, plot) -> np.matrix:
"""
Validação dos modelos com StratifiedKFold(n_splits=10) com a comparação de 30 resultados de cada modelo"""
resultados = {}
random_state = None
for modelo in self.lst_modelo:
# Cross validation Regressão com Árvore de Decisão
resultados[modelo] = self.get_metrics(X,
y,
pre,
random_state,
base,
scaled,
plt_text,
config,
kwargs,
validation,
plot,
modelo=modelo)
results = np.c_[resultados['arvore'], resultados['linear_poly'],
resultados['rede_neural'],
resultados['support_vector']]
ranks, names = self.control_validator.compare(results, self.lst_modelo)
validation = False
names = {
name.split(' - ')[0]: float(name.split(' - ')[1])
for name in names
}
result_rank = sorted(names, key=names.get)
modelos = {}
for i in range(2):
# Seleciona o melhor modelo de acordo com as comparações feitas acima pelo método de rankeamento Friedman-Nemenyi
modelo = self.get_metrics(X,
y,
pre,
random_state,
base,
scaled,
plt_text,
config,
kwargs,
validation,
plot,
modelo=result_rank[i],
selection=True)
modelos[result_rank[i]] = modelo
return results, modelos
class Regressor(object):
def __init__(self, X=np.array([]), y=np.array([]), ploter=list([])):
self.X = X
self.y = y
self.ploter = ploter
self.control_validator = ControlValidator()
self.control_analise = ControlAnalise()
def treinar_arvore(self, X, y, pre, scaled, plot, dct_text, validation,
kwargs):
"""
Recebe os valores previsores, targets e definição
Retorna o vetor com as predições de valoress para tabela de 2019 """
if 'boost' not in kwargs:
kwargs['boost'] = {}
# Instancia a classe para Regressão com Árvore de Decisão
regressor = AdaBoostRegressor(DecisionTreeRegressor(**kwargs['tree']),
**kwargs['boost'])
if len(kwargs['boost']) == 0:
kwargs = {}
if validation:
return self.control_validator.validate(X, y, regressor)
score, mae, previsoes = self.run_regressor(
X, (y[0].ravel(), y[1].ravel()), regressor, pre, scaled)
# Especifica as features mais relevantes para o modelo
feat_importances = regressor.feature_importances_
if plot:
if scaled:
y = (y[0], pre['scaler'][3].inverse_transform(y[1]))
# Calcula a média absoluta dos erros
# mae = mean_absolute_error(y[1], previsoes)
dict_modelo = {
'Nome': 'Regressão com Árvore de Decisão',
'Score': score,
'MAE': mae,
'Scale': scaled,
'kwargs': kwargs
}
self.ploter.append([X[2], y[1], previsoes, dct_text, dict_modelo])
if len(self.ploter) == 4:
self.ploter = self.control_analise.plotar_previsoes(
self.ploter)
return feat_importances, score, mae, regressor
def treinar_linear_poly(self, X, y, pre, scaled, plot, dct_text,
validation, kwargs):
"""
Recebe os valores previsores, targets e hiperparametros
Retorna o vetor com as predições de valoress para tabela de 2019 """
# Instancia o modelo regressor
regressor = LinearRegression(**kwargs)
if validation:
return self.control_validator.validate(X, y, regressor)
score, mae, previsoes = self.run_regressor(
X, (y[0].ravel(), y[1].ravel()), regressor, pre, scaled)
if plot:
if scaled:
y = (y[0], pre['scaler'][3].inverse_transform(y[1]))
# Calcula a média absoluta dos erros
# mae = mean_absolute_error(y[1], previsoes)
dict_modelo = {
'Nome': 'Regressão Linear(Polinomial)',
'Score': score,
'MAE': mae,
'Scale': scaled,
'kwargs': kwargs
}
self.ploter.append([
X[2], y[1],
previsoes.reshape(1, -1)[0], dct_text, dict_modelo
])
if len(self.ploter) == 4:
self.ploter = self.control_analise.plotar_previsoes(
self.ploter)
return score, mae, regressor
def treinar_redeneural(self, X, y, pre, scaled, plot, dct_text, validation,
kwargs):
"""
Recebe os valores previsores, targets e definição
Retorna o vetor com as predições de valoress para tabela de 2019 """
# Instancia o modelo regressor
regressor = MLPRegressor(**kwargs)
if validation:
return self.control_validator.validate(X, y, regressor)
score, mae, previsoes = self.run_regressor(
X, (y[0].ravel(), y[1].ravel()), regressor, pre, scaled)
# Reverte os valores para escala original
# y_test = scaler_y.inverse_transform(y_test)
# previsoes = scaler_y.inverse_transform(previsoes)
if plot:
# previsoes = pre['scaler'][3].inverse_transform(previsoes)
y = (y[0], pre['scaler'][3].inverse_transform(y[1]))
if not scaled:
previsoes = pre['scaler'][3].inverse_transform(previsoes)
# Calcula a média absoluta dos erros
mae = mean_absolute_error(y[1], previsoes)
dict_modelo = {
'Nome': 'Regressão com Rede Neural(MLP)',
'Score': score,
'MAE': mae,
'Scale': scaled,
'kwargs': kwargs
}
self.ploter.append([X[2], y[1], previsoes, dct_text, dict_modelo])
if len(self.ploter) == 4:
self.ploter = self.control_analise.plotar_previsoes(
self.ploter)
return score, mae, regressor
def treinar_svr(self, X, y, pre, scaled, plot, dct_text, validation,
kwargs):
"""
Recebe os valores previsores, targets e definição
Retorna o vetor com as predições de valoress para tabela de 2019 """
# Instancia o modelo regressor
regressor = SVR(**kwargs)
if validation:
return self.control_validator.validate(X, y, regressor)
score, mae, previsoes = self.run_regressor(
X, (y[0].ravel(), y[1].ravel()), regressor, pre, scaled)
# Reverte os valores para escala original
# y_test = scaler_y.inverse_transform(y_test)
# previsoes = scaler_y.inverse_transform(previsoes)
if plot:
y = (y[0], pre['scaler'][3].inverse_transform(y[1]))
if not scaled:
previsoes = pre['scaler'][3].inverse_transform(previsoes)
#previsoes = previsoes.reshape(1, -1)
# Calcula a média absoluta dos erros
mae = mean_absolute_error(y[1], previsoes)
dict_modelo = {
'Nome': 'Support Vector Regression',
'Score': score,
'MAE': mae,
'Scale': scaled,
'kwargs': kwargs
}
self.ploter.append(
[X[2], y[1].reshape(-1, 1), previsoes, dct_text, dict_modelo])
if len(self.ploter) == 4:
self.ploter = self.control_analise.plotar_previsoes(
self.ploter)
return score, mae, regressor
def run_regressor(self, X, y, regressor, pre, scaled):
"""
Recebe os valores previsores, targets e definição
Retorna o vetor com as predições de valoress para tabela de 2019 """
# if scaled:
# X = pre['scaler'][0]
# y = pre['scaler'][1]
# Treina o modelo
regressor.fit(X[0], y[0])
# Calcula o índice de acertos do modelo
score = regressor.score(X[1], y[1])
# Faz as predições dos targets especificados
previsoes = regressor.predict(X[1])
# Calcula a média absoluta dos erros
mae = mean_absolute_error(y[1], previsoes)
if scaled:
previsoes = pre['scaler'][3].inverse_transform(previsoes)
y = pre['scaler'][3].inverse_transform(y[1])
# Calcula a média absoluta dos erros
mae = mean_absolute_error(y, previsoes)
return score, mae, previsoes
def __init__(self):
self.validator = Validator()
self.control_analise = ControlAnalise()
self.resultados = []