"""Created some day. @author: J. Salmon, A. Gramfort, C. Vernade """ ############################################################################### # Import part ############################################################################### import numpy as np import matplotlib.pyplot as plt from matplotlib import cm from sklearn import neighbors, model_selection import seaborn as sns from matplotlib.colors import ListedColormap ############################################################################### # Data Generation ############################################################################### def rand_gauss(n=100, mu=[1, 1], sigmas=[0.1, 0.1]): """Sample points from a Gaussian variable. Parameters ---------- n : number of samples mu : centered sigma : standard deviation """ d = len(mu) res = np.random.randn(n, d) return np.array(res * sigmas + mu) def rand_bi_gauss(n1=100, n2=100, mu1=[1, 1], mu2=[-1, -1], sigmas1=[0.1, 0.1], sigmas2=[0.1, 0.1]): """Sample points from two Gaussian distributions. Parameters ---------- n1 : number of sample from first distribution n2 : number of sample from second distribution mu1 : center for first distribution mu2 : center for second distribution sigma1: std deviation for first distribution sigma2: std deviation for second distribution """ ex1 = rand_gauss(n1, mu1, sigmas1) ex2 = rand_gauss(n2, mu2, sigmas2) y = np.hstack([np.ones(n1), -1 * np.ones(n2)]) X = np.vstack([ex1, ex2]) ind = np.random.permutation(n1 + n2) return X[ind, :], y[ind] def rand_tri_gauss(n1=100, n2=100, n3=100, mu1=[1, 1], mu2=[-1, -1], mu3=[1, -1], sigma1=[0.1, 0.1], sigma2=[0.1, 0.1], sigma3=[0.1, 0.1]): """Sample points from two Gaussian distributions. Parameters ---------- n1 : number of sample from first distribution n2 : number of sample from second distribution n3 : number of sample from third distribution mu1 : center for first distribution mu2 : center for second distribution mu3 : center for third distribution sigma1: std deviation for first distribution sigma2: std deviation for second distribution sigma3: std deviation for third distribution """ ex1 = rand_gauss(n1, mu1, sigma1) ex2 = rand_gauss(n2, mu2, sigma2) ex3 = rand_gauss(n3, mu3, sigma3) X = np.vstack([ex1, ex2, ex3]) y = np.hstack([np.ones(n1), 2. * np.ones(n2), 3 * np.ones(n3)]) ind = np.random.permutation(n1 + n2 + n3) return X[ind, :], y[ind] def rand_clown(n1=100, n2=100, sigma1=1, sigma2=2): """Create samples and labels form a **clown** dataset. Parameters ---------- n1 : number of sample from first blob n2 : number of sample from second blob sigma1 : noise std deviation for the first blob sigma2 : noise std deviation for the second blob """ x0 = np.random.randn(n1, 1) x1 = x0 * x0 + sigma1 * np.random.randn(n1, 1) x2 = np.hstack([sigma2 * np.random.randn(n2, 1), sigma2 * np.random.randn(n2, 1) + 2.]) X = np.vstack([np.hstack([x0, x1]), x2]) y = np.hstack([np.ones(n1), -1 * np.ones(n2)]) ind = np.random.permutation(n1 + n2) return X[ind, :], y[ind] def rand_checkers(n1=100, n2=100, sigma=0.1): """Create samples and labels from a noisy checker. Parameters ---------- n1 : number of samples for the first class n2 : number of samples for the second class """ nbp = int(np.floor(n1 / 8)) nbn = int(np.floor(n2 / 8)) xapp = np.reshape(np.random.rand((nbp + nbn) * 16), [(nbp + nbn) * 8, 2]) yapp = np.ones((nbp + nbn) * 8) idx = 0 for i in range(-2, 2): for j in range(-2, 2): if (((i + j) % 2) == 0): nb = nbp else: nb = nbn yapp[idx:(idx + nb)] = [(i + j) % 3 + 1] * nb xapp[idx:(idx + nb), 0] = np.random.rand(nb) xapp[idx:(idx + nb), 0] += i + sigma * np.random.randn(nb) xapp[idx:(idx + nb), 1] = np.random.rand(nb) xapp[idx:(idx + nb), 1] += j + sigma * np.random.randn(nb) idx += nb ind = np.arange((nbp + nbn) * 8) np.random.shuffle(ind) res = np.hstack([xapp, yapp[:, np.newaxis]]) return np.array(res[ind, :2]), np.array(res[ind, 2]) ############################################################################### # Displaying labeled data ############################################################################### symlist = ['o', 'v', '^', '<', '>', '8', 's', 'p', '*', 'h', 'H', 'D', 'X'] def plot_2d(data, y=None, w=None, alpha_choice=1): """Plot in 2D the dataset data, colors and symbols according to the class given by the vector y (if given); the separating hyperplan w can also be displayed if asked""" k = np.unique(y).shape[0] color_blind_list = sns.color_palette("colorblind", k) sns.set_palette(color_blind_list) if y is None: labs = [""] idxbyclass = [range(data.shape[0])] else: labs = np.unique(y) idxbyclass = [np.where(y == labs[i])[0] for i in range(len(labs))] for i in range(len(labs)): plt.scatter(data[idxbyclass[i], 0], data[idxbyclass[i], 1], color=color_blind_list[i], s=80, marker=symlist[i]) plt.ylim([np.min(data[:, 1]), np.max(data[:, 1])]) plt.xlim([np.min(data[:, 0]), np.max(data[:, 0])]) mx = np.min(data[:, 0]) maxx = np.max(data[:, 0]) if w is not None: plt.plot([mx, maxx], [mx * -w[1] / w[2] - w[0] / w[2], maxx * -w[1] / w[2] - w[0] / w[2]], "g", alpha=alpha_choice) ############################################################################### # Displaying tools for the Frontiere ############################################################################### def frontiere(f, data, step=50, cmap_choice=cm.coolwarm, tiny=False): """ trace la frontiere pour la fonction de decision f""" xmin, xmax = data[:, 0].min() - 1., data[:, 0].max() + 1. ymin, ymax = data[:, 1].min() - 1., data[:, 1].max() + 1. xx, yy = np.meshgrid(np.arange(xmin, xmax, (xmax - xmin) * 1. / step), np.arange(ymin, ymax, (ymax - ymin) * 1. / step)) z = f(np.c_[xx.ravel(), yy.ravel()]) z = z.reshape(xx.shape) plt.imshow(z, origin='lower', interpolation="nearest", extent=[xmin, xmax, ymin, ymax], cmap=cmap_choice) if tiny: plt.xticks([]) plt.yticks([]) else: plt.colorbar() def frontiere_new(clf, X, y, w=None, step=50, alpha_choice=1, colorbar=True, samples=True, n_labels=3, n_neighbors=3): """Trace la frontiere pour la fonction de decision de clf.""" # min_tot0 = np.min(X[:, 0]) # min_tot1 = np.min(X[:, 1]) # max_tot0 = np.max(X[:, 0]) # max_tot1 = np.max(X[:, 1]) min_tot = np.min(X[:]) max_tot = np.max(X[:]) # delta0 = (max_tot0 - min_tot0) delta = (max_tot - min_tot) xx, yy = np.meshgrid(np.arange(min_tot, max_tot, delta / step), np.arange(min_tot, max_tot, delta / step)) XX = np.c_[xx.ravel(), yy.ravel()] z = np.array(clf.predict(XX)) z = z.reshape(xx.shape) labels = np.unique(z) color_blind_list = sns.color_palette("colorblind", labels.shape[0]) my_cmap = ListedColormap(color_blind_list) plt.imshow(z, origin='lower', interpolation="mitchell", alpha=0.80, cmap=my_cmap, extent=[min_tot, max_tot, min_tot, max_tot]) if colorbar is True: ax = plt.gca() cbar = plt.colorbar(ticks=labels) cbar.ax.set_yticklabels(labels) # color_blind_list = sns.color_palette("colorblind", labels.shape[0]) # sns.set_palette(color_blind_list) ax = plt.gca() if samples is True: for i, label in enumerate(y): label_num = np.where(labels == label)[0][0] plt.scatter(X[i, 0], X[i, 1], color=color_blind_list[label_num], s=80, marker=symlist[label_num]) plt.xlim([min_tot, max_tot]) plt.ylim([min_tot, max_tot]) ax.get_yaxis().set_ticks([]) ax.get_xaxis().set_ticks([]) if w is not None: plt.plot([min_tot, max_tot], [min_tot * -w[1] / w[2] - w[0] / w[2], max_tot * -w[1] / w[2] - w[0] / w[2]], "k", alpha=alpha_choice) plt.title("L=" + str(n_labels) + ",k=" + str(n_neighbors)) ############################################################################### # Algorithms and functions ############################################################################### class ErrorCurve(object): def __init__(self, k_range=None, weights='uniform'): if k_range is None: k_range = list(range(1, 6)) self.k_range = k_range self.weights = weights def fit_curve(self, X, y, Xtest, ytest): def error_func(k): knn = neighbors.KNeighborsClassifier(n_neighbors=k, weights=self.weights) knn.fit(X, y) error = np.mean(knn.predict(Xtest) != ytest) return error errors = list(map(error_func, self.k_range)) self.errors = np.array(errors) self.y = y def plot(self, marker='o', maketitle=True, **kwargs): plt.plot(self.k_range, self.errors, marker=marker, **kwargs) plt.xlabel("K") plt.ylabel("Test error") if maketitle: plt.title("number of training points : %d" % len(self.y)) class LOOCurve(object): """Leave-One-Out (LOO) curve.""" def __init__(self, k_range=None, weights='uniform'): if k_range is None: k_range = list(range(1, 6)) self.k_range = k_range self.weights = weights def fit_curve(self, X, y, n_splits=20, random_state=1): def score_func(k): # Selon la verson de scikit-learn : shuffleSplit prend en argument # 'niter ' ou niterations'. De plus, l'argument test_size peut ne # pas etre reconnu. Il est recommande de consulter # help(model_selection.ShuffleSplit) pour connaitre la liste # des arguments reconnus par votre version de sickitlearn. loo = model_selection.ShuffleSplit(n_splits=n_splits, test_size=0.8, random_state=random_state) knn = neighbors.KNeighborsClassifier(n_neighbors=k, weights=self.weights) scores = model_selection.cross_val_score(estimator=knn, X=X, y=y, cv=loo) return np.mean(scores) scores = list(map(score_func, self.k_range)) self.cv_scores = np.array(scores) self.y = y def plot(self, marker='o', maketitle=True, **kwargs): plt.plot(self.k_range, self.cv_scores, marker=marker, **kwargs) plt.xlabel("K") plt.ylabel("Leave One Out Score (1-error rate)") if maketitle: plt.title("number of training points : %d" % (len(self.y) - 1))