# 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()