def base_model(X_train, y_train,X_test, y_test): model = LogisticRegression(multi_class='auto',solver='lbfgs') visualizer = ROCAUC(model, classes=['dancehall','reggae','soca','pop']) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) visualizer.show()
def evaluation(estimator, X, Y, x, y): classes = [Y[1], Y[0]] f, (ax, ax1, ax2) = plt.subplots(1, 3, figsize=(18, 6)) #Confusion Matrix cmm = ConfusionMatrix(model=estimator, ax=ax1, classes=classes, label_encoder={ 0.0: 'Negativo', 1.0: 'Positivo' }) cmm.score(x, y) #ROCAUC viz = ROCAUC(model=estimator, ax=ax2) viz.fit(X, Y) viz.score(x, y) #Learning Curve cv_strategy = StratifiedKFold(n_splits=3) sizes = np.linspace(0.3, 1.0, 10) visualizer = LearningCurve(estimator, ax=ax, cv=cv_strategy, scoring='roc_auc', train_sizes=sizes, n_jobs=4) visualizer.fit(X, Y) cmm.poof(), viz.poof(), visualizer.poof() plt.show()
def eva_model(c, n, X, y, X_test, y_test, class_names, outdir): model = svm.LinearSVC(class_weight='balanced', dual=False, max_iter=10000, C=c) rfe = RFE(model, n_features_to_select=n) ## learning curve plt.clf() viz_LC = LearningCurve( rfe, scoring='f1_weighted', n_jobs=4 ) viz_LC.fit(X, y) viz_LC.show(outpath=outdir + '/LC.png') ## classification report plt.clf() viz_CR = ClassificationReport(rfe, classes=class_names, support=True) viz_CR.fit(X, y) viz_CR.score(X_test, y_test) viz_CR.show(outpath=outdir + '/CR.png') ## confusion matrix plt.clf() viz_CM = ConfusionMatrix(rfe, classes=class_names) viz_CM.fit(X, y) viz_CM.score(X_test, y_test) viz_CM.show(outpath=outdir + '/CM.png') ## precision recall curve plt.clf() viz_PRC = PrecisionRecallCurve(rfe, per_class=True, iso_f1_curves=True, fill_area=False, micro=False, classes=class_names) viz_PRC.fit(X, y) viz_PRC.score(X_test, y_test) viz_PRC.show(outpath=outdir + '/PRC.png',size=(1080,720)) ## class prediction error plt.clf() viz_CPE = ClassPredictionError( rfe, classes=class_names ) viz_CPE.fit(X, y) viz_CPE.score(X_test, y_test) viz_CPE.show(outpath=outdir + '/CPE.png') ## ROCAUC plt.clf() viz_RA = ROCAUC(rfe, classes=class_names, size=(1080,720)) viz_RA.fit(X, y) viz_RA.score(X, y) viz_RA.show(outpath=outdir + '/RA.png') fit = rfe.fit(X,y) y_predict = fit.predict(X_test) f1 = f1_score(y_test, y_predict, average='weighted') features_retained_RFE = X.columns[rfe.get_support()].values feature_df =pd.DataFrame(features_retained_RFE.tolist()) feature_df.to_csv(outdir + '/features.csv', sep='\t', index=False) return f1
def ROC_Curve(Model, X, y): X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.15) model = Model visualizer = ROCAUC(Model) visualizer.fit(X_train, y_train) # Fit the training data to the visualizer visualizer.score(X_test, y_test) # Evaluate the model on the test data visualizer.show()
def plotting_ROC_curve_yellowbrick(model, labels, X_train, y_train, X_test, y_test): st.subheader('ROC Curve') visualizer = ROCAUC(model, classes=labels) visualizer.fit(X_train, y_train) # Fit the training data to the visualizer visualizer.score(X_test, y_test) # Evaluate the model on the test data visualizer.show() st.pyplot() return
def ROC_AUC(model, classes, X_train, Y_train, X_test, Y_test): from yellowbrick.classifier import ROCAUC # Instantiate the visualizer with the classification model visualizer = ROCAUC(model, classes=classes) visualizer.fit(X_train, Y_train) # Fit the training data to the visualizer visualizer.score(X_test, Y_test) # Evaluate the model on the test data g = visualizer.poof()
def log_roc_auc_chart(classifier, X_train, X_test, y_train, y_test, experiment=None): """Log ROC-AUC chart. Make sure you created an experiment by using ``neptune.create_experiment()`` before you use this method. Tip: Check `Neptune documentation <https://docs.neptune.ai/integrations/scikit_learn.html>`_ for the full example. Args: classifier (:obj:`classifier`): | Fitted sklearn classifier object X_train (:obj:`ndarray`): | Training data matrix X_test (:obj:`ndarray`): | Testing data matrix y_train (:obj:`ndarray`): | The classification target for training y_test (:obj:`ndarray`): | The classification target for testing experiment (:obj:`neptune.experiments.Experiment`, optional, default is ``None``): | Neptune ``Experiment`` object to control to which experiment you log the data. | If ``None``, log to currently active, and most recent experiment. Returns: ``None`` Examples: .. code:: python3 rfc = RandomForestClassifier() rfc.fit(X_train, y_train) neptune.init('my_workspace/my_project') exp = neptune.create_experiment() log_roc_auc_chart(rfc, X_train, X_test, y_train, y_test, experiment=exp) """ assert is_classifier( classifier), 'classifier should be sklearn classifier.' exp = _validate_experiment(experiment) try: fig, ax = plt.subplots() visualizer = ROCAUC(classifier, is_fitted=True, ax=ax) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) visualizer.finalize() exp.log_image('charts_sklearn', fig, image_name='ROC-AUC') plt.close(fig) except Exception as e: print('Did not log ROC-AUC chart. Error {}'.format(e))
def classification_sanity_check(model, X_train, X_test, y_train, y_test, classes=None): visualizer = ROCAUC(model, micro=False, macro=False, classes=classes) visualizer.fit(X_train, y_train) # Fit the training data to the visualizer visualizer.score(X_test, y_test) # Evaluate the model on the test data visualizer.poof()
def roc_curve(self, classes) -> None: visualizer = ROCAUC(self.trained_model, classes=classes) visualizer.fit(self.X_train, self.y_train) # Fit the training data to the visualizer visualizer.score(self.X_test, self.y_test) # Evaluate the model on the test data save_dir = f"{self.plots_dir}/roc_curve_{self.model_id}.png" visualizer.show(outpath=save_dir) if not LOCAL: upload_to_s3(save_dir, f'plots/roc_curve_{self.model_id}.png', bucket=S3_BUCKET_NAME) plt.clf()
def create_roc_auc_chart(classifier, X_train, X_test, y_train, y_test): """Create ROC-AUC chart. Tip: Check Sklearn-Neptune integration `documentation <https://docs-beta.neptune.ai/essentials/integrations/machine-learning-frameworks/sklearn>`_ for the full example. Args: classifier (:obj:`classifier`): | Fitted sklearn classifier object X_train (:obj:`ndarray`): | Training data matrix X_test (:obj:`ndarray`): | Testing data matrix y_train (:obj:`ndarray`): | The classification target for training y_test (:obj:`ndarray`): | The classification target for testing Returns: ``neptune.types.File`` object that you can assign to run's ``base_namespace``. Examples: .. code:: python3 import neptune.new.integrations.sklearn as npt_utils rfc = RandomForestClassifier() rfc.fit(X_train, y_train) run = neptune.init(project='my_workspace/my_project') run['visuals/roc_auc'] = npt_utils.create_roc_auc_chart(rfc, X_train, X_test, y_train, y_test) """ assert is_classifier( classifier), 'classifier should be sklearn classifier.' chart = None try: fig, ax = plt.subplots() visualizer = ROCAUC(classifier, is_fitted=True, ax=ax) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) visualizer.finalize() chart = neptune.types.File.as_image(fig) plt.close(fig) except Exception as e: print('Did not log ROC-AUC chart. Error {}'.format(e)) return chart
def rocauc(X, y, model, outpath, **kwargs): # Create a new figure and axes _, ax = plt.subplots() # Instantiate the classification model and visualizer visualizer = ROCAUC(model, ax=ax, **kwargs) # Create the train and test data X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) # Save to disk visualizer.poof(outpath=outpath)
def rocauc(X, y, model, outpath, **kwargs): # Create a new figure and axes _, ax = plt.subplots() # Instantiate the classification model and visualizer visualizer = ROCAUC(model, ax=ax, **kwargs) # Create the train and test data X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) # Save to disk visualizer.poof(outpath=outpath)
def generate_roc_auc(self, X_train, y_train, X_test, y_test, **kwargs): """ Given the training and testing sets, computes the ROC AUC metrics for the given model and returns a ROC AUC plotly figure. :param X_train: the training feature set. :param y_train: the training target set. :param X_test: the testing feature set. :param y_test: the testing target set. """ visualizer = ROCAUC(self.model, classes=self.classes) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) roc_data = visualizer.tpr layout = go.Layout(yaxis = dict( scaleratio = 1, range=[-.1, 1] ), xaxis=dict( range=[-.1, 1], #scaleratio = 1 ), ) fig = go.Figure(layout=layout) for tr in roc_data.keys(): trace = go.Scatter( x = [i / len(roc_data[tr]) for i in range(len(roc_data[tr]))], y = roc_data[tr], name = f'{tr}' if type(tr) != int else f'{self.classes[tr]}', line = dict(shape = 'hv') ) fig.add_trace(trace) lin_line = go.Scatter( x = [0,1], y = [0,1], name = 'linear_line', line = dict(dash='dash') ) fig.add_trace(lin_line) return fig
def evaluate_model(clf_, X_tr, X_te, y_tr, y_te, cls_rpt_tr=False, show=True, cls_labels=None, binary=False): """Takes any classifier, train/test data for X/y, labels for graph (optional). Will output (if show) a Sklearn Classification Report and Confusion Matrix along with a Yellowbrick ROC/AUC curve and Feature Importance graph (if a tree). Otherwise will return training/test predictions.""" import sklearn.metrics as metrics import matplotlib.pyplot as plt from yellowbrick.classifier import ROCAUC ## Fit and predict y_hat_trn, y_hat_tes = fit_n_pred(clf_, X_tr, X_te, y_tr) if show: ## Classification Report / Scores if cls_rpt_tr: print('Classification Report Train') print(metrics.classification_report(y_tr,y_hat_trn)) else: print('Classification Report Test') print(metrics.classification_report(y_te,y_hat_tes)) ## Confusion Matrix fig, ax = plt.subplots(figsize=(10,5), ncols=2) metrics.plot_confusion_matrix(clf_,X_te,y_te,cmap="YlOrRd", normalize='true',ax=ax[0]) ax[0].set(title='Confusion Matrix Test Data') ax[0].grid(False) roc = ROCAUC(clf_, classes=cls_labels, ax=ax[1]) roc.fit(X_tr, y_tr) roc.score(X_te, y_te) roc.finalize() plt.tight_layout() plt.show() if binary: try: imps = plot_importance(clf_, X_tr) except: imps = None else: return y_hat_trn, y_hat_tes
def roc(model, data_type="music", features_nr=705): classes = ["{}".format(data_type), "no_{}".format(data_type)] from yellowbrick.classifier import ROCAUC data = load_data(how_many=4, last=True, data_type=data_type) data = data.astype({'class': str}) features = data.columns[:features_nr] X = data[features] y = data["class"] # Instantiate the visualizer with the classification model visualizer = ROCAUC(model, classes=classes) visualizer.score(X, y) # Evaluate the model on the test data g = visualizer.poof() # Draw/show/poof the data
def rocauc(dataset): if dataset == "binary": X, y = load_occupancy() model = GaussianNB() elif dataset == "multiclass": X, y = load_game() X = OrdinalEncoder().fit_transform(X) model = RidgeClassifier() else: raise ValueError("uknown dataset") X_train, X_test, y_train, y_test = tts(X, y, test_size=0.2) oz = ROCAUC(model, ax=newfig()) oz.fit(X_train, y_train) oz.score(X_test, y_test) savefig(oz, "rocauc_{}".format(dataset))
def evaluate_model(model,x_test,y_test,coef_): prediction = model.predict(x_test) acc_test = accuracy_score(y_test,prediction) acc_train = accuracy_score(y_train,model.predict(X_train)) print("\n") print("Accuracy Score(Test): " + str(acc_test)) print("Accuracy Score(Train): " + str(acc_train)) print("Difference between train and test accuracy = {0}".format(abs(acc_test-acc_train))) print("Roc Auc Score: "+ str(roc_auc_score(y_test,prediction))) print("\n") print("Classification Report:") print(classification_report(y_test,prediction)) # confusion matrix plt.figure() cm = confusion_matrix(y_test,prediction) sns.heatmap(cm,annot=True,cmap="YlGnBu",fmt="d") plt.title("Confusion Matrix(1:Churned, 0:Not Churned)") plt.show() # roc-curve plt.figure() visualizer = ROCAUC(model, classes=["Not Churn", "Churn"]) visualizer.fit(X_train, y_train) # Fit the training data to the visualizer visualizer.score(X_test, y_test) # Evaluate the model on the test data visualizer.show() # Finalize and show the figure plt.show() if coef_: feature_imp ={} for idx,col_name in enumerate(X_train.columns): feature_imp[col_name] = model.coef_[0][idx] feature_imp = pd.DataFrame(feature_imp.items(),columns = ["Feature","Feature Importance"]) feature_imp.set_index("Feature",inplace=True) ax = feature_imp.plot(kind="bar",fontsize=10,color="red") ax.set_title("Future Importance",fontdict={"fontsize":12,"fontweight":"bold"}) ax.set_ylabel("Coef_") plt.show()
def rocauc(ax): from yellowbrick.classifier import ROCAUC from sklearn.linear_model import LogisticRegression # Specify the features of interest and the classes of the target features = ["temperature", "relative humidity", "light", "C02", "humidity"] target = "occupancy" classes = ['unoccupied', 'occupied'] # Load the data splits = load_data('occupancy', cols=features, target=target, tts=True) X_train, X_test, y_train, y_test = splits estimator = LogisticRegression() visualizer = ROCAUC(estimator, ax=ax) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) return visualizer
def showROC(): # Load the classification data set data = load_data('occupancy') # Specify the features of interest and the classes of the target features = ["temperature", "relative humidity", "light", "C02", "humidity"] classes = ['unoccupied', 'occupied'] # Extract the numpy arrays from the data frame X = data[features].as_matrix() y = data.occupancy.as_matrix() # Create the train and test data X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2) # Instantiate the classification model and visualizer logistic = LogisticRegression() visualizer = ROCAUC(logistic) visualizer.fit(X_train, y_train) # Fit the training data to the visualizer visualizer.score(X_test, y_test) # Evaluate the model on the test data g = visualizer.poof() # Draw/show/poof the data
def get_roc(self, on="test"): visualizer = ROCAUC(self.pipe) if on == "test": visualizer.score(self._X_test, self._y_test) elif on == "train": visualizer.score(self._X_train, self._y_train) elif on == "all": visualizer.score(self.X, self.y) visualizer.poof()
def get_roc(self, on="test"): """ Produces aAUC/ROC curve graph made through the yellowbrick package Input ----- on : string (default=test) Determines which set of data to score and create a ROC graph on. Default is 'test', meaning it will make a ROC graph of the test results. 'train' and 'all' are alternative values. """ visualizer = ROCAUC(self.pipe) if on == "test": visualizer.score(self._X_test, self._y_test) elif on == "train": visualizer.score(self._X_train, self._y_train) elif on == "all": visualizer.score(self._X, self._y) visualizer.poof()
def plot(X, Y): X_train, X_test, y_train, y_test = train_test_split(X, Y, test_size=0.2) oz = ROCAUC(GaussianNB()) oz.fit(X_train, y_train) oz.score(X_test, y_test) oz.poof()
y_pred = model.predict(X_test) # Making the Confusion Matrix from sklearn.metrics import confusion_matrix import seaborn as sn import matplotlib.pyplot as plt cmET = confusion_matrix(y_test, y_pred) sn.heatmap(cmET, cmap='Blues_r', annot=True, xticklabels='1234', yticklabels='1234') plt.xlabel('Predicted Label') plt.ylabel('Actual Label') plt.show() #ROCAUC Plot from sklearn.preprocessing import OrdinalEncoder, LabelEncoder from yellowbrick.classifier import ROCAUC # Encode the non-numeric columns X = OrdinalEncoder().fit_transform(X) y = LabelEncoder().fit_transform(y) # Instaniate the classification model and visualizer visualizer = ROCAUC(model, Damage=[1, 2, 3, 4]) visualizer.fit(X_train, y_train) # Fit the training data to the visualizer visualizer.score(X_test, y_test) # Evaluate the model on the test data visualizer.show() # Finalize and render the figure
####################################################### # STEP 5: Accuracy check ######################################################### from sklearn import metrics prediction_test = model.predict(X_test) ##Check accuracy on test dataset. print ("Accuracy = ", metrics.accuracy_score(y_test, prediction_test)) from yellowbrick.classifier import ROCAUC print("Classes in the image are: ", np.unique(Y)) #ROC curve for RF roc_auc=ROCAUC(model, classes=[0, 1, 2, 3]) #Create object roc_auc.fit(X_train, y_train) roc_auc.score(X_test, y_test) roc_auc.show() ########################################################## #STEP 6: SAVE MODEL FOR FUTURE USE ########################################################### ##You can store the model for future use. In fact, this is how you do machine elarning ##Train on training images, validate on test images and deploy the model on unknown images. # # ##Save the trained model as pickle string to disk for future use model_name = "sandstone_model" pickle.dump(model, open(model_name, 'wb')) # ##To test the model on future datasets #loaded_model = pickle.load(open(model_name, 'rb'))
datasets = DatasetMixin() credit = datasets.load_data('credit') credit_keys = credit.dtype.names datatype = credit.dtype[0] ncols = len(credit_keys) categorical_names = ['edu','married'] y_name = 'default' credit_data = None for j in range(0,ncols): if credit_keys[j] in categorical_names: credit_data = add_categorical(credit_data,credit[credit_keys[j]],datatype) elif credit_keys[j] == y_name: y = credit[y_name].astype(int) else: credit_data = add_column(credit_data,credit[credit_keys[j]]) datashape = credit_data.shape nrows = datashape[0] cmeans = np.mean(credit_data,0) repmeans = numpy.matlib.repmat(cmeans,nrows,1) mydata = credit_data - repmeans sstds = np.std(mydata,0) repstds = numpy.matlib.repmat(sstds,nrows,1) mydata = np.divide(mydata,repstds) visualizer = ROCAUC(LinearSVC()) visualizer.fit(mydata,y) visualizer.score(mydata,y) visualizer.poof()
def train(experiment_id, run_name, xtrain, xtest, ytrain, ytest): 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
class_names = ['+', '-'] verbose_class_names = ['Activator', 'Repressor'] # %% X = load('X.joblib') y = load('y.joblib') # %% to_graphviz(clf, num_trees=0, rankdir='LR') # %% classification_report(clf, X, y) # %% visualizer = ROCAUC(clf, classes=class_names) visualizer.score(X, y) visualizer.poof() # %% visualizer = ClassPredictionError(clf, classes=class_names) visualizer.score(X, y) visualizer.poof() # %% visualizer = DiscriminationThreshold(clf) visualizer.fit(X, y) visualizer.poof() # %% keep = [263, 268, 287, 288, 300, 302, 307, 308, 313, 315]
def baseline_model(df): X_train=df.drop('is_click',axis=1) with open(r'./baseline_logistic.pkl','wb') as f: pickle.dump(X_train,f) logistic=LogisticRegression() cv_res=cross_validation(logistic,X_train,df['is_click']) plot_cv_res(cv_res) return logistic.fit(X_train,df['is_click']),X_train def predict_test_values(test_df,model,transformer): vect=transformer.transform(test_df['tweet']) predictions=model.predict(vect) df=pd.DataFrame() df['id']=test_df['id'].values df['label']=predictions return df log,X_train=baseline_model(train) test_df=pd.read_csv(r'./Data/test.csv') with open(r'./Models/baseline_logistic.pkl','rb') as f: X_train=pickle.load(f) pred_df=predict_test_values(test_df,log,X_train) pred_df.to_csv('./Submissions/baseline_predictions.csv',index=False) #pca,arr=dimesionality_reduction(X_train.toarray()) #plot_reduced_dimension(arr,train['is_click']) visualizer = ROCAUC(log) visualizer.score(X_train,train['label']) visualizer.poof() feature_series=pd.Series(index=X_train.columns,data=X_train.values)
plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.title('Receiver operating characteristic') plt.legend(loc="lower right") plt.savefig('Log_ROC') plt.show() # Yellowbrick visualization viz = ClassificationReport(model) viz.fit(X_train, y_train) viz.score(X_test, y_test) viz.show() roc = ROCAUC(model) roc.fit(X_train, y_train) roc.score(X_test, y_test) roc.show() # # Perform Gridsearch using various parameters penalty = ['l1', 'l2'] C = [0.1, 0.25, 0.5] solver = ['newton-cg', 'lbfgs', 'liblinear'] class_weight = [{0: 15, 1: 85}, {0: 0.14, 1: 0.86}] miter = [5000] hyperparams = dict(C=C, penalty=penalty, solver=solver, class_weight=class_weight, max_iter=miter) RegLog = LogisticRegression() finalmodel = GridSearchCV(RegLog, hyperparams, verbose=0, cv=5) finalmodel.fit(X_train, y_train)
test_mean = np.mean(test_scores, axis=1) test_mean test_std = np.std(test_scores, axis=1) test_std plt.plot(train_sizes, train_mean, label='Training Score') plt.plot(train_sizes, test_mean, label='Cross-Validation Score') plt.fill_between(train_sizes, train_mean - train_std, train_mean + train_std, color='#DDDDDD') plt.fill_between(train_sizes, test_mean - test_std, test_mean + test_std, color='#DDDDDD') plt.title("Learning Curve") plt.xlabel("Training Size") plt.ylabel("Accuracy Score") plt.legend(loc='best') """**ROC ve AUC**""" from yellowbrick.classifier import ROCAUC fig, ax = plt.subplots(1, 1, figsize=(12, 8)) roc_auc = ROCAUC(clf, ax=ax) roc_auc.fit(pc_train, y_train) roc_auc.score(pc_test, y_test) roc_auc.poof()
def best_model(model): visualizer = ROCAUC(model, classes=['reggae','soca','dancehall','pop']) visualizer.fit(X_train, y_train) visualizer.score(X_test, y_test) visualizer.show()