# train
start_time = time.perf_counter()
clf.fit(X_train, y_train)
training_time = time.perf_counter() - start_time
print("training time = " + str(training_time))
print("stopped at iterations = " + str(clf.n_iter_))
# test on train set
y_train_pred = clf.predict(X_train)
train_kappa = metrics.cohen_kappa_score(y_train, y_train_pred)
train_error = metrics.accuracy_score(y_train, y_train_pred)
print("TRAINING kappa=" + str(train_kappa))
print("TRAINING error=" + str(train_error))
# test
y_test_pred = clf.predict(X_test)
test_kappa = metrics.cohen_kappa_score(y_test, y_test_pred)
test_error = metrics.accuracy_score(y_test, y_test_pred)
print("TEST kappa=" + str(test_kappa))
print("TEST error=" + str(test_error))
# plot confusion matrix
title = LABEL + ": Confusion Matrix"
cm = ConfusionMatrix(clf, classes=[0, 1], title=title)
cm.fit(X_train, y_train)
cm.score(X_test, y_test)
cm.show(outpath=path.join(PLOT_DIR, ABBREV + "_confusion.png"))
cm.show()
plt.close()
print('X matrix dimensionality:', X.shape)
print('Y vector dimensionality:', Y.shape)
# split the data into a training set and a test set
X_train, X_validation, Y_train, Y_validation = model_selection.train_test_split(
X, Y, test_size=0.20, random_state=10)
# print("X_train: ", X_train.shape)
# print("X_validation: ", X_validation.shape))
# print("Y_train: ", Y_train.shape))
# print("Y_validation: ", Y_validation.shape))
svc = SVC(kernel='rbf', gamma='auto', C=6)
cm = ConfusionMatrix(
svc,
classes="A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z".split(','))
# train the model using the training sets
cm.fit(X_train, Y_train)
cm.score(X_validation, Y_validation)
# predict the responses for test dataset
predictions = cm.predict(X_validation)
# accuracy classification score
print("Accuracy: ", accuracy_score(Y_validation, predictions))
# compute confusion matrix
print(confusion_matrix(Y_validation, predictions))
classe,
test_size=0.3,
random_state=0)
# Treinamento do modelo
naive_bayes = GaussianNB()
naive_bayes.fit(X_train, y_train)
# Teste do modelo
previsoes = naive_bayes.predict(X_test)
confusao = confusion_matrix(y_test, previsoes)
taxaAcerto = accuracy_score(y_test, previsoes)
taxaErro = 1 - taxaAcerto
from yellowbrick.classifier import ConfusionMatrix
visualizador = ConfusionMatrix(GaussianNB())
visualizador.fit(X_train, y_train)
visualizador.score(X_test, y_test)
visualizador.poof
# Intâncias nos dados de teste classificados como "bom": 214, "ruim": 86
# Diante dessa informação, identifica-se que as linhas da visualização
# correspodem aos dados de teste, e as colunas aos dados de previsão.
df_y_test = pd.DataFrame(y_test, columns=['classe'])
df_y_test[df_y_test['classe'] == 'bom'].count() #214
df_y_test[df_y_test['classe'] == 'ruim'].count() #86
# Taxa de inadimplência como resultado do teste: 20,1%
falsoPositivo = confusao[1, 0]
verdadeiraPositivo = confusao[0, 0]
taxaInadimplencia = falsoPositivo / (falsoPositivo + verdadeiraPositivo)
def modeltrain(experiment_id, run_name, xtrain, xtest, ytrain, ytest):
"""
This function takes six arguments and return pickle file, images
Paramters:
----------
experiment_id: int
run_name: str
xtrain: file
xtest: file
ytrain: file
ytest: file
Returns
-------
pickle file
images file
"""
np.random.seed(100)
with mlflow.start_run(experiment_id=experiment_id,
run_name=run_name) as run:
tfid_vect = TfidfVectorizer(analyzer='word',
tokenizer=nltk.tokenize.word_tokenize,
stop_words='english',
min_df=5)
my_pipeline = Pipeline(
steps=[('vectorizer',
tfid_vect), ('lr', LogisticRegression(random_state=42))])
my_pipeline.fit(xtrain, ytrain)
predictions = my_pipeline.predict(xtest)
joblib.dump(my_pipeline, 'pipeline_lr.pkl')
accuracy = accuracy_score(ytest, predictions)
f1score = f1_score(ytest, predictions)
auc_score = roc_auc_score(ytest, predictions)
class_report = classification_report(ytest, predictions)
print(f'Accuracy : {round(accuracy, 2)}')
print(f'f1_score : {round(f1score, 2)}')
print(f'auc_score : {round(auc_score, 2)}')
print(f'class_report : \n {class_report}')
mlflow.log_metric('Accuracy', round(accuracy, 2))
mlflow.log_metric('f1_score', round(f1score, 2))
mlflow.log_metric('auc_score', round(auc_score, 2))
fig, (ax1, ax2, ax3, ax4) = plt.subplots(nrows=4)
visualizer = ClassificationReport(my_pipeline, ax=ax1, classes=[0, 1])
visualizer.fit(xtrain, ytrain)
visualizer.score(xtest, ytest)
a = visualizer.poof(outpath="image/classification_report.png")
print(' ')
mlflow.log_artifact("image/classification_report.png")
# The ConfusionMatrix visualizer taxes a model
cm = ConfusionMatrix(my_pipeline, ax=ax2, classes=[0, 1])
cm.fit(xtrain, ytrain)
cm.score(xtest, ytest)
b = cm.poof(outpath="image/confusionmatrix.png")
mlflow.log_artifact("image/confusionmatrix.png")
print(' ')
vis = ROCAUC(my_pipeline, ax=ax3, classes=[0, 1])
vis.fit(xtrain, ytrain) # Fit the training data to the visualizer
vis.score(xtest, ytest) # Evaluate the model on the test data
c = vis.poof(outpath="image/rocauc.png") # Draw/show/poof the data
print(' ')
mlflow.log_artifact("image/rocauc.png")
visual = ClassPredictionError(my_pipeline, ax=ax4, classes=[0, 1])
visual.fit(xtrain, ytrain)
visual.score(xtest, ytest)
g = visual.poof(outpath="image/ClassificationError.png")
print(' ')
mlflow.log_artifact("image/ClassificationError.png")
return run.info.run_uuid
from sklearn.datasets import load_digits
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from yellowbrick.classifier import ConfusionMatrix
if __name__ == '__main__':
# Load the regression data set
digits = load_digits()
X = digits.data
y = digits.target
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size=0.2,
random_state=11)
model = LogisticRegression()
#The ConfusionMatrix visualizer taxes a model
cm = ConfusionMatrix(model, classes=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
cm.fit(X_train, y_train) # Fit the training data to the visualizer
cm.score(X_test, y_test) # Evaluate the model on the test data
g = cm.poof(
outpath="images/confusion_matrix.png") # Draw/show/poof the data
# predecir
predicciones1 = modelo1.predict(X_probar)
#calcular la precisión
accuracy_score(y_probar, predicciones1)
print('salida: ',accuracy_score(y_probar, predicciones1))
#y_probar = vector de prueba
#precciones1 = vector de predicciones
#Generar la matriz de confusion
confusion1= ConfusionMatrix(modelo1)
confusion1.fit(X_entrenar, y_entrenar)
confusion1.score(X_probar, y_probar)
confusion1.poof()
#Mejorar (modelar)
modelo2 = DecisionTreeClassifier(criterion = 'entropy', min_samples_split = 100)
modelo2.fit(X_entrenar, y_entrenar)
export_graphviz(modelo1, out_file = 'modelo2.dot')
predicciones2 = modelo1.predict(X_probar)
#calcular la precisión
accuracy_score(y_probar, predicciones2)
print('salida: ',accuracy_score(y_probar, predicciones2))
#y_probar = vector de prueba
previsores = Arquivo.iloc[:, 0:4].values
classe = Arquivo.iloc[:, 3].values
labelencoder = LabelEncoder(
) #Prepara os atributos para analise (todos os que não forem numericos) altera os atributos categoricos em numericos
previsores[:, 0] = labelencoder.fit_transform(previsores[:, 0])
previsores[:, 1] = labelencoder.fit_transform(previsores[:, 1])
previsores[:, 2] = labelencoder.fit_transform(previsores[:, 2])
previsores[:, 3] = labelencoder.fit_transform(previsores[:, 3])
X_treinamento, X_teste, y_treinamento, y_teste = train_test_split(
previsores, classe, test_size=0.3, random_state=0)
arvore = DecisionTreeClassifier()
arvore.fit(X_treinamento, y_treinamento)
export_graphviz(arvore, out_file='tree.dot')
previsoes = arvore.predict(X_teste)
confusao = confusion_matrix(y_teste, previsoes)
taxa_acerto = accuracy_score(y_teste, previsoes)
taxa_erro = 1 - taxa_acerto
print(previsoes)
print(confusao)
print(taxa_acerto)
print(taxa_erro)
from yellowbrick.classifier import ConfusionMatrix #Biblioteca específica para visualização da matriz de confusão
v = ConfusionMatrix(DecisionTreeClassifier()) #Cria o visualizador
v.fit(X_treinamento, y_treinamento) #Fazendo o treinamento
v.score(X_teste, y_teste) #Fazendo o score
v.poof() #Cria visualizador
"""
como foi constatado na comparação entre previsões e y_teste, há algumas previsões que vieram com erro (isso é comum)
precisamos agora contabilizar essa taxa de erros
"""
confusao = confusion_matrix(y_teste, previsoes)
#obtivemos 71% de acerto com esse algoritmo
taxa_acerto = accuracy_score(y_teste, previsoes)
taxa_erro = 1 - taxa_acerto
"""
como na matrix de confusão gerada pela confusion_matrix da sklearn não conseguimos distinguir os valores pra good e bad,
vamos importar a ConfusionMatrix da yellowbrick e gerar uma nova matriz de confusão
no resultado lê-se:
------------------------------------------------------------
| bad classificado como bad | bad classificado como good |
------------------------------------------------------------
| good classificado como bad | good classificado como good |
------------------------------------------------------------
"""
from yellowbrick.classifier import ConfusionMatrix
visualizador = ConfusionMatrix(GaussianNB())
visualizador.fit(X_treinamento, y_treinamento)
visualizador.score(X_teste, y_teste)
visualizador.poof() #para visualizar
classifiers[key] = classifier
# Get results
results = pd.DataFrame()
for key in classifiers:
# Make prediction on test set
y_pred = classifiers[key].predict(X_test)
# Save results in pandas dataframe object
results[f"{key}"] = y_pred
# Add the test set to the results object
results["Target"] = y_test
results
from yellowbrick.classifier import ClassificationReport
classes = ["0","1"]
model = sclf
visualizer = ClassificationReport(model, classes=classes, support=True)
cm = ConfusionMatrix(model, classes=classes)
cm.fit(X_train, y_train)
cm.score(X_test, y_test)
cm.show()
visualizer.fit(X_train, y_train)
visualizer.score(X_test, y_test)
visualizer.show()
previsores[:, 9] = labelencoder.fit_transform(previsores[:, 9])
previsores[:, 11] = labelencoder.fit_transform(previsores[:, 11])
previsores[:, 13] = labelencoder.fit_transform(previsores[:, 13])
previsores[:, 14] = labelencoder.fit_transform(previsores[:, 14])
previsores[:, 16] = labelencoder.fit_transform(previsores[:, 16])
previsores[:, 18] = labelencoder.fit_transform(previsores[:, 18])
previsores[:, 19] = labelencoder.fit_transform(previsores[:, 19])
#divisão dos dados em treinamento(70%) e teste(30%)
x_treinamento, x_teste, y_treinamento, y_teste = train_test_split(
previsores, classe, test_size=0.3, random_state=0)
#vai gerar 100 árvores de decisão
floresta = RandomForestClassifier(n_estimators=100)
floresta.fit(x_treinamento, y_treinamento)
previsoes = floresta.predict(x_teste)
confusao = confusion_matrix(y_teste, previsoes)
visualizador = ConfusionMatrix(RandomForestClassifier())
visualizador.fit(x_treinamento, y_treinamento)
visualizador.score(x_teste, y_teste)
visualizador.poof()
indice_acertos = accuracy_score(y_teste, previsoes)
print(indice_acertos)
indice_erros = 1 - indice_acertos
#floresta.estimators_ #mostra as árvores que foram criadas
#floresta.estimators_[2] #mostra a terceira árvore gerada
# In[ ]:
#%% [markdown]
### Quality metrics
#%%
# Selected features
print("\nOptimal number of features : %d \n" % rfecv.n_features_)
# a = np.column_stack((rfecv.ranking_, adata2.var_names)) #combine ranks with genes
# a[a[:,0].argsort()][1:100,1] # print top100 ranks
#
# Training data
#
# Confusion Matrix
cm = ConfusionMatrix(rfecv, classes=["Tnaive", "Treg", "Teff_mem"])
cm.score(X_test, y_test)
cm.poof()
print(metrics.accuracy_score(y_test, y_pred))
#
# New data
#
# Confusion matrix
y_louvain = adata1.obs['louvain_03'] #cluster
df_conf_norm = pd.crosstab(y_louvain, y_new, normalize='index') # + normalize
sns.heatmap(df_conf_norm, annot=True, cmap="viridis")
# Test accuracy
def confusion_matrix(ax):
# from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from yellowbrick.classifier import ConfusionMatrix
features = [
"a1",
"a2",
"a3",
"a4",
"a5",
"a6",
"b1",
"b2",
"b3",
"b4",
"b5",
"b6",
"c1",
"c2",
"c3",
"c4",
"c5",
"c6",
"d1",
"d2",
"d3",
"d4",
"d5",
"d6",
"e1",
"e2",
"e3",
"e4",
"e5",
"e6",
"f1",
"f2",
"f3",
"f4",
"f5",
"f6",
"g1",
"g2",
"g3",
"g4",
"g5",
"g6",
]
classes = ['win', 'loss', 'draw']
splits = load_data('game', cols=features, target='outcome', tts=True)
X_train, X_test, y_train, y_test = splits
labels = LabelEncoder()
estimator = Pipeline([
('encoder', MultiColumnEncoder()),
('onehot', OneHotEncoder()),
('dense', ToDense()),
('maxent', RandomForestClassifier()),
])
visualizer = ConfusionMatrix(estimator, ax=ax)
visualizer.fit(X_train, y_train)
visualizer.score(X_test, y_test)
return visualizer
from sklearn.datasets import load_digits, load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split as tts
from yellowbrick.classifier import ConfusionMatrix
if __name__ == '__main__':
digits = load_digits()
digit_X = digits.data
digit_y = digits.target
d_X_train, d_X_test, d_y_train, d_y_test = tts(digit_X,
digit_y,
test_size=0.2)
model = LogisticRegression()
digit_cm = ConfusionMatrix(model, classes=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
digit_cm.fit(d_X_train, d_y_train)
digit_cm.score(d_X_test, d_y_test)
d = digit_cm.poof(outpath="images/confusion_matrix_digits.png")
iris = load_iris()
iris_X = iris.data
iris_y = iris.target
iris_classes = iris.target_names
i_X_train, i_X_test, i_y_train, i_y_test = tts(iris_X,
iris_y,
test_size=0.2)
model = LogisticRegression()
iris_cm = ConfusionMatrix(model,
classes=iris_classes,
label_encoder={
0: 'setosa',
X[:, 16] = labelencoder.fit_transform(X[:, 16])
X[:, 17] = labelencoder.fit_transform(X[:, 17])
X[:, 18] = labelencoder.fit_transform(X[:, 18])
X[:, 19] = labelencoder.fit_transform(X[:, 19])
X[:, 20] = labelencoder.fit_transform(X[:, 20])
X[:, 21] = labelencoder.fit_transform(X[:, 21])
X[:, 22] = labelencoder.fit_transform(X[:, 22])
X[:, 23] = labelencoder.fit_transform(X[:, 23])
X[:, 24] = labelencoder.fit_transform(X[:, 24])
X[:, 25] = labelencoder.fit_transform(X[:, 25])
# Dividindo a base de dados em treinamentp e teste
X_treinamento, X_teste, y_treinamento, y_teste = train_test_split(
X, y, test_size=0.3, random_state=0)
modelo = GaussianNB()
modelo.fit(
X_treinamento,
y_treinamento) # Aqui é criado a tabela de probabilidade no naive bayes
previsoes = modelo.predict(X_teste)
# Realizando um comparativo entre y_teste e os resutados da variável previsões e ter o percentual
accuracy_score(y_teste, previsoes)
# Matriz de confusão
confusao = ConfusionMatrix(modelo,
classes=['None', 'Severe', 'Mild', 'Moderate'])
confusao.fit(X_treinamento, y_treinamento)
confusao.score(X_teste, y_teste)
confusao.poof()
print(' score cross validation :{}'.format(result))
print('moyenne score cross validation : {:.2f}'.format(result.mean()))
result1 = cross_val_score(arbre, x_train, y_train, cv=kplis)
print(' score kplis cross validation :{}'.format(result1))
print('moyenne score cross validation : {:.2f}'.format(result1.mean()))
result2 = cross_val_score(arbre, x_train, y_train, cv=kplis_strat)
print(' score kplis strat cross validation :{}'.format(result2))
print('moyenne score cross validation : {:.2f}'.format(result2.mean()))
result3 = cross_val_score(arbre, x_train, y_train, cv=shuffle)
print(' score shuffle split cross validation :{}'.format(result3))
print('moyenne score cross validation : {:.2f}'.format(result3.mean()))
cm = ConfusionMatrix(arbre, classes=[0, 1, 2, 3, 4, 5, 6], percent=True)
cm.fit(x_train, y_train)
cm.score(x_test, y_test)
cm.poof()
size = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8]
lc = LearningCurve(DecisionTreeClassifier(), train_sizes=size, score='r2')
lc.fit(x_train, y_train)
lc.poof()
''' ---------------------- Forêt aléatoire ------------------------'''
foret = RandomForestClassifier(n_estimators=120,
max_features='sqrt',
n_jobs=-1,
random_state=0)
foret.fit(x_train, y_train)
Arquivo = pd.read_csv('aco.csv') #Arquivo usado para analise (treino e teste)
previsores = Arquivo.iloc[:, 0:4].values #Seleciona os atributos previsores
classe = Arquivo.iloc[:, 3].values #Seleciona o atributo classificador
labelencoder = LabelEncoder(
) #Prepara os atributos para analise (todos os que não forem numericos) altera os atributos categoricos em numericos
previsores[:, 0] = labelencoder.fit_transform(previsores[:, 0])
previsores[:, 1] = labelencoder.fit_transform(previsores[:, 1])
previsores[:, 2] = labelencoder.fit_transform(previsores[:, 2])
previsores[:, 3] = labelencoder.fit_transform(previsores[:, 3])
X_treinamento, X_teste, y_treinamento, y_teste = train_test_split(
previsores, classe, test_size=0.3, random_state=0
) #DIvide a base em teste e treinamento. Deixando a base de treinamento com 30% do tamanho, rando sempre divide a base da mesma forma
naive_bayes = GaussianNB() #Cria o classificador
naive_bayes.fit(X_treinamento, y_treinamento) #Usa os dados para classificação
previsoes = naive_bayes.predict(X_teste) # Faz as previsões
print(previsoes)
confusao = confusion_matrix(y_teste, previsoes) #Cria matriz de confusão
print(confusao)
taxa_acerto = accuracy_score(y_teste, previsoes) # Teste de acuracia
print(taxa_acerto)
taxa_erro = 1 - taxa_acerto
print(taxa_erro)
from yellowbrick.classifier import ConfusionMatrix #Biblioteca específica para visualização da matriz de confusão
v = ConfusionMatrix(GaussianNB()) #Cria o visualizador
v.fit(X_treinamento, y_treinamento) #Fazendo o treinamento
v.score(X_teste, y_teste) #Fazendo o score
v.poof() #Cria visualizador
print(y_val.value_counts())
#%%
# step 20: Eval Metrics
from sklearn.linear_model import LogisticRegression
from yellowbrick.classifier import ConfusionMatrix
from yellowbrick.classifier import ClassificationReport
from yellowbrick.classifier import ROCAUC
# Instantiate the classification model
model = LogisticRegression()
#The ConfusionMatrix visualizer taxes a model
classes = ['Below Avg', 'Above Avg']
cm = ConfusionMatrix(model, classes=classes, percent=False)
# fit the model
cm.fit(x_train, y_train)
#To create the ConfusionMatrix, we need some test data. Score runs predict() on the data
#and then creates the confusion_matrix from scikit learn.
cm.score(x_val, y_val)
# change fontsize of the labels in the figure
for label in cm.ax.texts:
label.set_size(20)
#How did we do?
cm.poof()
# Plot also the training points
plot.scatter(X[:, 0], X[:, 1], c=Y, edgecolors='k')
plot.xlabel('2007')
plot.ylabel('2011')
plot.xlim(xx.min(), xx.max())
plot.ylim(yy.min(), yy.max())
plot.xticks(())
plot.yticks(())
plot.show()
# In[38]:
cm = ConfusionMatrix(decision, classes=[0, 1, 2])
cm.fit(X_train, y_train)
cm.score(X_test, y_test)
cm.poof()
# In[39]:
#Prediction
# In[40]:
df1.drop([
'Location_RegionId', 'export', 'import', 'Employment_share_in_pop',
'GDP_in_USD', 'GNI_in_USD', 'Loan_Share',
'Total_health_exp_in_share_of_GDP', "Status"
],
def execute_classification_code(code, session):
global df, model, problem_class, order
code_str = urllib.parse.unquote(code)
code_arr = code_str.split("\n")
print(code_arr)
problem_class = code_arr[0]
print(problem_class)
order = code_arr[1]
print(order)
exec(code_arr[2])
print(df)
exec(code_arr[3], globals())
cmap_pink_green = sns.diverging_palette(352, 136, s=96, l=51, n=7)
viz = ClassificationReport(model, cmap=cmap_pink_green)
viz.fit(X_train, y_train)
viz.score(X_test, y_test)
viz.poof(outpath="./plots/classificationmatrix" + session + ".png")
image_path_class = "classificationmatrix"
plt.clf()
plt.cla()
plt.close()
le = LabelEncoder()
dec_viz = DecisionViz(model,
title="Decision Boundaries",
features=np.where(cols == True)[0].tolist(),
classes=list(map(str, y.iloc[:, 0].unique())).sort())
dec_viz.fit(X_train.to_numpy(), le.fit_transform(y_train))
dec_viz.draw(X_test.to_numpy(), le.fit_transform(y_test))
dec_viz.poof(outpath="./plots/decviz" + session + ".png")
image_path_dec = "decviz"
plt.clf()
plt.cla()
plt.close()
print(list(map(str, y.iloc[:, 0].unique())))
cmap_salmon_dijon = sns.diverging_palette(28, 65, s=98, l=78, n=7)
cm = ConfusionMatrix(model,
classes=list(map(str, y.iloc[:, 0].unique())).sort(),
cmap=cmap_salmon_dijon)
cm.fit(X_train, y_train)
cm.score(X_test, y_test)
plt.tight_layout()
cm.poof(outpath="./plots/cm" + session + ".png")
image_path_cm = "cm"
plt.clf()
plt.cla()
plt.close()
model.fit(X_train, y_train)
file = 'pickled_models/trained_model' + session + '.sav'
pickle_path = 'trained_model'
pickle.dump(model, open(file, 'wb'))
return jsonify(image_path_class, image_path_dec, image_path_cm,
pickle_path)
)
#Criação do modelo utilizando holdout
p_treinamento, p_teste, c_treinamento, c_teste = train_test_split(
previsores, classe, test_size=0.2, random_state=0)
clf.fit(p_treinamento, c_treinamento)
# Resultados da predição
c_previsao = clf.predict(p_teste)
#Mostra a matriz de confusão e a previsão do modelo
precisao = metrics.accuracy_score(c_teste, c_previsao)
matriz = metrics.confusion_matrix(c_teste, c_previsao)
#Gera o imagem da matriz de confusão
v = ConfusionMatrix(clf)
v.fit(p_treinamento, c_treinamento)
v.score(p_teste, c_teste)
v.poof()
#Geração de um gráfico comparando o desempenho da validação cruzada com a divisão de dados
plt.figure(figsize=(10, 5))
plt.title('Medição da acurácia do modelo - GaussianNB',
fontsize=16,
fontweight='bold')
plt.xlabel('Tipo de modelo', fontsize=12, fontweight='bold')
plt.ylabel('Precisão (%)', fontsize=12, fontweight='bold')
bar1 = plt.bar('Validação Cruzada',
round(metrics.accuracy_score(classe, resultados) * 100, 2),
color='r',
width=0.3)
# Imporatando MultiLayer perceptron
from sklearn.neural_network import MLPClassifier
# Fazendo a divisão da base de dados entre treinamento e teste
from sklearn.model_selection import train_test_split
# Comparativos de erros e acertos da base de dados
from sklearn.metrics import accuracy_score
# Visualizando a matrix de confusão
from yellowbrick.classifier import ConfusionMatrix
# Carregamentos do datasets
iris = datasets.load_iris()
# Dividindo a base de dados em treinamentp e teste
X_treinamento, X_teste, y_treinamento, y_teste = train_test_split(
iris.data, iris.target, test_size=0.3, random_state=0)
modelo = MLPClassifier(verbose=True, hidden_layer_sizes=(5, 4), max_iter=10000)
modelo.fit(X_treinamento, y_treinamento)
previsoes = modelo.predict(X_teste)
accuracy_score(y_teste, previsoes)
# Matriz de confusão
confusao = ConfusionMatrix(modelo)
confusao.fit(X_treinamento, y_treinamento)
confusao.score(X_teste, y_teste)
confusao.poof()
#divisão dos dados em treinamento(70%) e teste(30%)
x_treinamento, x_teste, y_treinamento, y_teste = train_test_split(
previsores, classe, test_size=0.3, random_state=0)
arvore = DecisionTreeClassifier() #obj
#Gerando a árvore
arvore.fit(x_treinamento, y_treinamento)
#visualizando a árvore - abra o .dot, copie o código
#cole no http://www.webgraphviz.com/ e clique em Generate Graph
#poderemos ver a árvore de decisão completa lá, que é efetivamente
#a aprendizagem desse algoritmo
export_graphviz(arvore, out_file='tree.dot')
#Fazendo as previsões: testando os dados 30% separados para teste
#utilizando o modelo previamente gerado pela árvore de decisão
previsoes = arvore.predict(x_teste)
#Gerando a matriz de confusão - frequências de classificação para cada classe do modelo
confusao = confusion_matrix(y_teste, previsoes)
#visualização da matriz de confusão bonitinha
visualizador = ConfusionMatrix(DecisionTreeClassifier())
visualizador.fit(x_treinamento, y_treinamento)
visualizador.score(x_teste, y_teste)
visualizador.poof()
indice_acertos = accuracy_score(y_teste, previsoes)
print(indice_acertos)
indice_erros = 1 - indice_acertos
# In[ ]:
classe = dados.iloc[:, 0].values
#Aqui iremos transformar as colunas categóricas em colunas numéricas
labelencoder = LabelEncoder()
previsores[:, 0] = labelencoder.fit_transform(previsores[:, 0])
#Aqui hávera a divisão dos dados para treinamento e teste passando como parâmetros(variavel independente, variável resposta, a amostra de teste[0 até 1] e divisao da base de dados igual)
X_treinamento, X_teste, y_treinamento, y_teste = train_test_split(
previsores, classe, test_size=0.3, random_state=0)
#Agora vamos aplicar o naive bays nos dados de treinamento (executa os dois comandos simultaneamente)
naive_bayes = GaussianNB()
naive_bayes.fit(X_treinamento, y_treinamento)
#Pega os dados passados no passo anterior para ser executado no modelo
previsoes = naive_bayes.predict(X_teste)
#gera uma variável com uma matriz de confusão
confusao = confusion_matrix(y_teste, previsoes)
#Revela o percentual de acerto e erro do modelo da máquina
taxa_acerto = accuracy_score(y_teste, previsoes)
taxa_erro = 1 - taxa_acerto
#Aqui irá gerá a figura da matriz de confusão (executar os 4 comandos simultaneamente)
v = ConfusionMatrix(naive_bayes)
v.fit(X_treinamento, y_treinamento)
v.score(X_teste, y_teste)
v.poof()
'''Obs: Como constatado, a taxa de acerto do modelo foi 64.4%, aproximadamente, com 30% de dados para teste.'''
x_train_new = select_top.fit_transform(x_train, y_train)
x_test_new = select_top.fit_transform(x_test, y_test)
print('Top train features', x_train.columns.values[select_top.get_support()])
print('Top train features', x_test.columns.values[select_top.get_support()])
c = [1.0, 0.25, 0.5, 0.75]
kernels = ['linear', 'rbf']
gammas = ['auto', 0.01, 0.001, 1] #1/n_feature
svm = SVC()
grid_svm = GridSearchCV(estimator = svm, param_grid = dict(kernel = kernels, C = c, gamma = gammas), cv = 5)
grid_svm.fit(x_train_new, y_train)
print('The best hyperparamters: ', grid_svm.best_estimator_)
svc_model = SVC(C = 1, gamma='auto', kernel='linear')
svc_model.fit(x_train_new, y_train)
print('The train accuracy', svc_model.score(x_train_new, y_train))
print('The test accuracy', svc_model.score(x_test_new, y_test))
y_pred = svc_model.predict(x_test_new)
accuracy_score(y_test, y_pred)
confusion_matrix(y_test, y_pred)
cm = ConfusionMatrix(svc_model, classes = [0, 1, 2, 3])
cm.fit(x_train_new, y_train)
cm.score(x_test_new, y_test)
cm.poof()
le = LabelEncoder()
df_data_encoder = df_data.apply(lambda col: le.fit_transform(col))
X_train, X_test, y_train, y_test = \
train_test_split(df_data_encoder, df_class, test_size = 0.3, random_state = 0)
modelo = GaussianNB()
# modelo = MultinomialNB()
modelo.fit(X_train, y_train)
y_pred = modelo.predict(X_test)
matrix = confusion_matrix(y_test, y_pred)
accuracy_score(y_test, y_pred)
# np.sum(matrix.diagonal()) / np.sum(matrix)
# yeallowbrick
from yellowbrick.classifier import ConfusionMatrix
confusion = ConfusionMatrix(GaussianNB())
# confusion = ConfusionMatrix(MultinomialNB())
confusion.fit(X_train, y_train)
confusion.score(X_test, y_test)
confusion.poof()
### Em produção
df_novo_credit = pd.read_csv('NovoCredit.csv', sep=',')
df_novo_data = df_novo_credit.apply(lambda col: le.fit_transform(col))
modelo.predict(df_novo_data)
test_size = 0.3,
random_state = 0)
#aplicacao do treinamento. Gera a tabela de probabilidade
naive_bayes = GaussianNB()
naive_bayes.fit(X_treinamento, y_treinamento)
#previsoes. Submete cada registro do X_teste ao modelo treinado e da resposta
#good ou bad de acordo com a tabela de probabilidade gerada no treinamento
previsoes = naive_bayes.predict(X_teste)
#contabilizicao dos erros e acertos comparando o dado real com o dado previsto
confusao = confusion_matrix(y_teste, previsoes)
taxa_acerto = accuracy_score(y_teste, previsoes)
#visualizacao da tabela de acerto
v = ConfusionMatrix(GaussianNB())
v.fit(X_treinamento, y_treinamento)
v.score(X_teste, y_teste)
v.poof()
#aplicacao para clientes novos
novo_credito = pd.read_csv('NovoCredit.csv')
novo_credito = novo_credito.iloc[:, 0:20].values #transforma o formato em numpy array
#os dados devem ser os mesmos do treinamento, e na mesma ordem
novo_credito[:,0] = labelencoder.fit_transform(novo_credito[:,0])
novo_credito[:,2] = labelencoder.fit_transform(novo_credito[:,2])
novo_credito[:,3] = labelencoder.fit_transform(novo_credito[:,3])
novo_credito[:,5] = labelencoder.fit_transform(novo_credito[:,5])
novo_credito[:,6] = labelencoder.fit_transform(novo_credito[:,6])
novo_credito[:,8] = labelencoder.fit_transform(novo_credito[:,8])
novo_credito[:,9] = labelencoder.fit_transform(novo_credito[:,9])
def yellowbrick_visualizations(model, classes, X_tr, y_tr, X_te, y_te):
visualizer = ConfusionMatrix(model, classes=classes)
visualizer.fit(X_tr, y_tr)
visualizer.score(X_te, y_te)
visualizer.show()
visualizer = ClassificationReport(model, classes=classes, support=True)
visualizer.fit(X_tr, y_tr)
visualizer.score(X_te, y_te)
visualizer.show()
visualizer = ROCAUC(model, classes=classes)
visualizer.fit(X_tr, y_tr)
visualizer.score(X_te, y_te)
visualizer.show()
labelencoder = LabelEncoder()
previsores[:, 0] = labelencoder.fit_transform(previsores[:, 0])
#Aqui hávera a divisão dos dados para treinamento e teste
X_treinamento, X_teste, y_treinamento, y_teste = train_test_split(
previsores, classe, test_size=0.3, random_state=0)
#Criação do algoritmo da árvore de decisão, juntamente com o treinamento do algoritmo
arvore = DecisionTreeClassifier()
arvore.fit(X_treinamento, y_treinamento)
#Gera um arquivo de texto no diretório específico onde o código está salvo, copia o texto que foi gerado e cola na aba lá presente no site webgraphviz.com para gerar a árvore.
export_graphviz(arvore, out_file='tree2.dot')
#Faz as previsões da variável teste.
previsoes = arvore.predict(X_teste)
#Gera uma variável com a matriz de confusão
confusao = confusion_matrix(y_teste, previsoes)
#Gera duas variáveis com as taxas de acertos e erros da árvore de decisão
taxa_acerto = accuracy_score(y_teste, previsoes)
taxa_erro = 1 - taxa_acerto
#Gera o imagem da matriz de confusão
v = ConfusionMatrix(arvore)
v.fit(X_treinamento, y_treinamento)
v.score(X_teste, y_teste)
v.poof()
'''Obs: Como constatado, a taxa de acerto do modelo foi 93.3%, aproximadamente, com 30% de dados para teste.'''
from yellowbrick.classifier import ROCAUC
roc = ROCAUC(xgb, classes=cancer.target_names)
roc.fit(X_train, y_train)
roc.score(X_test, y_test)
roc.poof()
### Confusion Matrix
from yellowbrick.classifier import ConfusionMatrix
classes = cancer.target_names
conf_matrix = ConfusionMatrix(xgb,
classes=classes,
label_encoder={
0: 'benign',
1: 'malignant'
})
conf_matrix.fit(X_train, y_train)
conf_matrix.score(X_test, y_test)
conf_matrix.poof()
### Class Prediction Error
from yellowbrick.classifier import ClassPredictionError
visualizer = ClassPredictionError(xgb, classes=classes)
visualizer.fit(X_train, y_train)
visualizer.score(X_test, y_test)
visualizer.poof()
from sklearn.datasets import load_digits, load_iris
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split as tts
from yellowbrick.classifier import ConfusionMatrix
if __name__ == '__main__':
digits = load_digits()
digit_X = digits.data
digit_y = digits.target
d_X_train, d_X_test, d_y_train, d_y_test = tts(
digit_X, digit_y, test_size=0.2
)
model = LogisticRegression()
digit_cm = ConfusionMatrix(model, classes=[0,1,2,3,4,5,6,7,8,9])
digit_cm.fit(d_X_train, d_y_train)
digit_cm.score(d_X_test, d_y_test)
d = digit_cm.poof(outpath="images/confusion_matrix_digits.png")
iris = load_iris()
iris_X = iris.data
iris_y = iris.target
iris_classes = iris.target_names
i_X_train, i_X_test, i_y_train, i_y_test = tts(
iris_X, iris_y, test_size=0.2
)
model = LogisticRegression()
iris_cm = ConfusionMatrix(
model, classes=iris_classes,
def plot_confusion_matrix(model, X_valid, y_valid):
visualizer = ConfusionMatrix(model, is_fitted=True)
visualizer.score(X_valid, y_valid)
visualizer.poof()
