def plot_training_curve(self, xticks_step=5): evolution = pd.DataFrame({ 'Generation': self.log.select("gen"), 'Max Accuracy': self.log.select("max"), 'Average Accuracy': self.log.select("avg"), 'Min Accuracy': self.log.select("min") }) plt.title('Hyperparameter Optimisation') plt.plot(evolution['Generation'], evolution['Min Accuracy'], 'b', color='C1', label='Min') plt.plot(evolution['Generation'], evolution['Average Accuracy'], 'b', color='C2', label='Average') plt.plot(evolution['Generation'], evolution['Max Accuracy'], 'b', color='C3', label='Max') plt.legend(loc='lower right') plt.ylabel('Accuracy') plt.xlabel('Generation') plt.xticks( [x for x in range(0, self.number_of_generations + 1, xticks_step)]) plt.show()
def plot_learning_curve(model, x_train, y_train, train_sizes_ratio=np.linspace(0.1, 1.0, 10), k=10, scorer=None): """ :param model: :param x_train: :param y_train: :param train_sizes_ratio: :param k: :param scorer: :return: """ N, train_score, val_score = learning_curve(model, x_train, y_train, train_sizes=train_sizes_ratio, cv=k, scoring=scorer) learning_curve_data = {'train': train_score, 'test': val_score} for legend, scores in learning_curve_data.items(): plt.plot(N, np.abs(scores.mean(axis=1)), label=legend) plt.xlabel('train_sizes', labelpad=20) plt.legend() plt.show()
def plot_validation_curve(model, x_train, y_train, h_param, h_range, k=10, log_scale=False, scorer=None): train_score, val_score = validation_curve(model, x_train, y_train, h_param, h_range, cv=k, scoring=scorer) validation_curve_data = {'train': train_score, 'test': val_score} for legend, scores in validation_curve_data.items(): if log_scale: plt.semilogx(h_range, np.abs(scores.mean(axis=1)), label=legend) else: plt.plot(h_range, np.abs(scores.mean(axis=1)), label=legend) plt.xlabel(h_param, labelpad=20) plt.ylabel('score', labelpad=20) plt.legend() plt.show()
def plot_regularization_path(alphas, coefs, features_labels, n_features_labels=None, legend_size='medium'): """ :param alphas: :param coefs: :param features_labels: :param n_features_labels: :param legend_size: :return: """ plt.figure(figsize=(12, 6)) ax = plt.gca() ax.plot(alphas, coefs) ax.set_xscale('log') plt.xlabel('Alpha') plt.ylabel('Coefficients') plt.legend(features_labels[:n_features_labels] if n_features_labels is not None else features_labels, loc='upper right', fontsize=legend_size) plt.show()
def plot_training_curve(history, value_type='accuracy', fine_tuning=False, initial_epochs=None): """ https://machinelearningmastery.com/diagnose-overfitting-underfitting-lstm-models/ """ plt.plot(history.history[value_type]) plt.plot(history.history[f'val_{value_type}']) if fine_tuning: plt.plot([initial_epochs - 1, initial_epochs - 1], plt.ylim(), label='Start Fine Tuning') plt.title('Training curve') plt.ylabel(value_type.capitalize()) plt.xlabel('Epoch') plt.legend(['train', 'test'], loc='upper left') plt.show()
def scree_plot(self, threshold=None, save_as_img=False): # (% Explained Variance) """ """ scree = self.evr * 100 plt.bar(np.arange(len(scree)) + 1, scree) if threshold is not None: scree_freq = scree / scree.sum() scree_cumsum = np.cumsum(scree_freq) # Number of features needed for threshold cumulative importance n_features = np.min(np.where(scree_cumsum > threshold)) + 1 threshold_percentage = 100 * threshold threshold_legend = '{} features required for {:.0f}% of inertia.'.format( n_features, threshold_percentage) # Threshold vertical line plot plt.vlines(n_features, ymin=0, ymax=threshold_percentage, linestyles='--', colors='red') plt.plot(np.arange(len(scree)) + 1, scree.cumsum(), c="red", marker='o', label=threshold_legend) plt.legend(loc='lower right', fontsize=12) else: plt.plot(np.arange(len(scree)) + 1, scree.cumsum(), c="red", marker='o') plt.xlabel("Inertia axis rank", labelpad=20) plt.ylabel("Inertia (%)", labelpad=20) plt.title("Scree plot" + "\n(Kaiser criterion = {} : Elbow criterion = {})".format( self.kaiser_criterion(), elbow_criterion(total_inertia=self.evr)), pad=20) if save_as_img: plt.tight_layout() plt.savefig('scree.jpg') plt.show(block=False)
def plot_roc_curve(y_test, y_predicted, curve_color='coral', font_size=14, x_lim=(0, 1), y_lim=(0, 1)): """ cf : - https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html """ fpr, tpr, thr = roc_curve(y_test, y_predicted) auroc = auc(fpr, tpr) plt.plot(fpr, tpr, label=f'AUROC : {auroc:.2f}', color=curve_color, lw=2) # Random classifier line plot plt.plot([0, 1], [0, 1], linestyle='--') plt.xlim(x_lim) plt.ylim(y_lim) plt.xlabel('1 - specificity (FPR)', fontsize=font_size) plt.ylabel('Recall (TPR)', fontsize=font_size) plt.title('Receiver operating characteristic') plt.legend(loc="lower right")
def plot_factorial_planes(self, n_plan=None, X_projected=None, labels=None, alpha=1, illustrative_var=None, illustrative_var_title=None, save_as_img=False, plot_size=(10, 8)): """ :param: axis_nb: the total number of axes to display (default is kaiser criterion divided by 2) """ X_projected = self.X_projected if X_projected is None else X_projected factorial_plan_nb = self.default_factorial_plan_nb if n_plan is None else n_plan axis_ranks = [(x, x + 1) for x in range(0, factorial_plan_nb, 2)] for d1, d2 in axis_ranks: if d2 < self.n_comp: fig = plt.figure(figsize=plot_size) # Display data points if illustrative_var is None: plt.scatter(X_projected[:, d1], X_projected[:, d2], alpha=alpha) else: illustrative_var = np.array(illustrative_var) for value in np.unique(illustrative_var): selected = np.where(illustrative_var == value) plt.scatter(X_projected[selected, d1], X_projected[selected, d2], alpha=alpha, label=value) plt.legend(title=illustrative_var_title if illustrative_var_title is not None else None) # Display data points labels if labels is not None: for i, (x, y) in enumerate(X_projected[:, [d1, d2]]): plt.text(x, y, labels[i], fontsize='12', ha='center', va='bottom') # Fix factorial plan limits boundary = np.max(np.abs(X_projected[:, [d1, d2]])) * 1.1 plt.xlim([-boundary, boundary]) plt.ylim([-boundary, boundary]) # Display horizontal & vertical lines plt.plot([-100, 100], [0, 0], color='grey', ls='--') plt.plot([0, 0], [-100, 100], color='grey', ls='--') # Axes labels with % explained variance plt.xlabel('F{} ({}%)'.format(d1 + 1, round(100 * self.evr[d1], 1)), labelpad=20) plt.ylabel('F{} ({}%)'.format(d2 + 1, round(100 * self.evr[d2], 1)), labelpad=20) plt.title("Projection des individus (sur F{} et F{})".format( d1 + 1, d2 + 1), pad=20) if save_as_img: plt.tight_layout() plt.savefig( 'factorial_plan_{}.jpg'.format(1 if d1 == 0 else d1)) plt.show(block=False)