def chartData(data, keyword): #Takes input of the results of the fts search and the phrase that was searched for #and creates bar chart of occurences by book for the phrase from matplotlib import pyplot as plt import numpy as np import math data = sorted(data, key=lambda x: x[1], reverse=True) info = []#number of occurences books = []#list of books for d in data: info.append(d[1]) b = d[0] books.append(b[b.find('LIBER'):])#Use only book number for label since name is the same for all books #create chart plt.close() fig = plt.figure() width = 0.4 ind = np.arange(len(books)) plt.bar(ind, info, width=width) plt.xticks(ind + width/2., books) plt.yticks(np.arange(0,max(info)*2,math.ceil(max(info)/5))) plt.ylabel('Number of Occurences') plt.xlabel('Books') plt.title('Occurences of "' + keyword + '" by book in Curtius Rufus (Latin)') fig.autofmt_xdate() plt.show(block=False)#display plot, and continue with program
def plot_confusion_matrix(confusion_matrix, class_labels, normalize=False, title='Confusion Matrix', cmap=plt.cm.Blues): """ Code courtesy of Abinav Sagar: https://towardsdatascience.com/convolutional-neural-network-for-breast-cancer-classification-52f1213dcc9 """ if normalize: confusion_matrix = confusion_matrix.astype( 'float') / confusion_matrix.sum(axis=1)[:, np.newaxis] print("Normalized confusion matrix") else: print('Confusion matrix, without normalization') print(confusion_matrix) plt.imshow(confusion_matrix, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() tick_marks = np.arange(len(class_labels)) plt.xticks(tick_marks, class_labels, rotation=55) plt.yticks(tick_marks, class_labels) fmt = '.2f' if normalize else 'd' thresh = confusion_matrix.max() / 2. for i, j in itertools.product(range(confusion_matrix.shape[0]), range(confusion_matrix.shape[1])): plt.text(j, i, format(confusion_matrix[i, j], fmt), horizontalalignment="center", color="white" if confusion_matrix[i, j] > thresh else "black") plt.ylabel('True label') plt.xlabel('Predicted label') plt.tight_layout()
def check_sanity(): fig = plt.figure(figsize=[10, 5]) # Axes for flower image ax = fig.add_axes([.5, .4, .5, .5]) # Displaay image result = process_image('flowers/test/1/image_06743.jpg') ax = imshow(result, ax) ax.axis('off') index = 77 ax.set_title(cat_to_name[str(index)]) # Prediction of image predictions, classes = predict('flowers/test/1/image_06743.jpg', model, device=device) # Create bar graph # Axis x and y ax1 = fig.add_axes([0, -.4, .888, .888]) # Classes probability y_pos = np.arange(len(classes)) # Horizontal bar chart to see it better plt.barh(y_pos, predictions, align='center', alpha=0.5) plt.yticks(y_pos, classes) plt.xlabel('probabilities') plt.show()
def plot_confusion_matrix(cls_pred, cls_true): # This is called from print_test_accuracy() below. # cls_pred is an array of the predicted class-number for # all images in the test-set. # Get the true classifications for the test-set. # Get the confusion matrix using sklearn. cm = confusion_matrix(y_true=cls_true, y_pred=cls_pred) # Print the confusion matrix as text. print(cm) # Plot the confusion matrix as an image. plt.matshow(cm) # Make various adjustments to the plot. plt.colorbar() tick_marks = np.arange(labels_type) plt.xticks(tick_marks, range(labels_type)) plt.yticks(tick_marks, range(labels_type)) plt.xlabel('Predicted') plt.ylabel('True') # Ensure the plot is shown correctly with multiple plots # in a single Notebook cell. plt.show()
def plotColorCodedNetworkSpikes(network): assert network is not None, "Network is not initialised! Visualising failed." import matplotlib as plt from NetworkBuilder import sameDisparityInd cellsOutSortedByDisp = [] spikes = [] for disp in range(0, maxDisparity+1): cellsOutSortedByDisp.append([network[x][2] for x in sameDisparityInd[disp]]) spikes.append([x.getSpikes() for x in cellsOutSortedByDisp[disp]]) sortedSpikes = sortSpikesByColor(spikes) print sortedSpikes framesOfSpikes = generateColoredFrames(sortedSpikes) print framesOfSpikes fig = plt.figure() initialData = createInitialisingDataColoredPlot() imNet = plt.imshow(initialData[0], c=initialData[1], cmap=plt.cm.coolwarm, interpolation='none', origin='upper') plt.xticks(range(0, dimensionRetinaX)) plt.yticks(range(0, dimensionRetinaY)) plt.title("Disparity Map {0}".format(disparity)) args = (framesOfSpikes, imNet) anim = animation.FuncAnimation(fig, animate, fargs=args, frames=int(simulationTime)*10, interval=30) plt.show()
def plotConfusionMatrix(lbllist, predlist, classes, type): confusionMatrix = confusion_matrix(lbllist, predlist) # print(confusionMatrix) plt.imshow(confusionMatrix, interpolation="nearest", cmap=plt.cm.Blues) if type == 'train': plt.title("Confusion matrix training") elif type == 'test': plt.title("Confusion matrix testing") plt.colorbar() tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45) plt.yticks(tick_marks, classes) fmt = "d" thresh = confusionMatrix.max() / 2. for i, j in itertools.product(range(confusionMatrix.shape[0]), range(confusionMatrix.shape[1])): plt.text(j, i, format(confusionMatrix[i, j], fmt), horizontalalignment="center", color="white" if confusionMatrix[i, j] > thresh else "black") plt.tight_layout() plt.ylabel("True label") plt.xlabel("Predicted label") # plt.show() if type == 'train': plt.savefig(LOG_PATH + 'Confusion matrix training.png') elif type == 'test': plt.savefig(LOG_PATH + 'Confusion matrix testing.png') plt.close()
def plot_confusion_matrix(cm, classes, title='混淆矩阵', cmap=plt.cm.Greens): # imshow() 表示绘制并显示二维图 有18个参数 # 参数1 X 混淆矩阵中显示的数值 二维数组 # 参数2 cmap 颜色 plt.cm.Blues表示蓝色 plt.cm.Reds表示红色 plt.cm.Greens表示绿色 # 参数5 interpolation 插值法 一般有如下值 # nearest 最近邻插值法 # bilinear 双线性插值法 plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['axes.unicode_minus'] = False plt.imshow(cm, cmap=cmap, interpolation="nearest") plt.title(title) # 标题 plt.colorbar() # 显示颜色的进度条 tick_marks = np.arange(2) # [0 1] plt.xticks(tick_marks, classes) # 对x轴上分类进行标记 plt.yticks(tick_marks, classes) # 对y轴上分类进行标记 thresh = np.mean(cm) for i in range(2): for j in range(2): plt.text(i, j, cm[j][i], horizontalalignment='center', color='white' if cm[i][j] >= thresh else 'black') plt.xlabel('预测值') plt.ylabel('真实值')
def plot_test_image(testX, image_index, predictions_array, true_binary_labels): """ testX: this is the test dataset image_index: index of the image that we will plot from the test dataset predictions_array: it is the array that contains all the predictions of the test dataset as output of model.predict(testX) true_binary_labels: these are the true label expressed as INTEGER values. It does not work with hot-encoding and string labels. """ single_predictions_array, true_binary_label, test_image = predictions_array, true_binary_labels[ image_index], testX[image_index] plt.grid(False) plt.xticks([]) plt.yticks([]) plt.imshow(test_image, cmap=plt.cm.binary) predicted_binary_label = np.argmax(predictions_array) #print ("predicted_binary_label:", predicted_binary_label) #print ("true_binary_label:",true_binary_label) if predicted_binary_label == true_binary_label: color = 'blue' else: color = 'red' plt.xlabel("predicted: {} {:2.0f}% (true: {})".format( predicted_binary_label, 100 * np.max(single_predictions_array), true_binary_label), color=color)
def test_random_forest(T=1000): """ Method for testing the random forest algorithm with bank dataset. Problem #2.2d in HW2 for CS3505 T = number of times algorithm will be run """ import matplotlib.pyplot as plt S_train = read_file('train.csv', "bank") S_train, medians, majority = process_bank_data(S_train, "train") S_test = read_file('test.csv', "bank") S_test, medians, _ = process_bank_data(S_test, "test", medians) master_list = create_attribute_dictionary("bank") for s in (2,4,6): training_errors = [] testing_errors = [] for i in range(T): ensemble = random_forest(S_train, master_list, i, s) training_errors.append(100 - test_ensemble(ensemble, S_train)*100) testing_errors.append(100 - test_ensemble(ensemble, S_test)*100) #plot the error rates versus the no of trees print("Sample size: " + str(s)) plt.title('Error rates per no of trees\nRandom Forest') plt.xlabel('No. of Trees') plt.ylabel('Percentage Incorrect') plt.plot(training_errors, label="train") plt.plot(testing_errors, label="test") plt.legend(loc='lower right') plt.yticks(np.arange(0, 20, 5)) plt.show()
def musicType_plot(rap, randb, classical, indie, pop, df): plt.figure() # declaring testing data xs = [1, 2, 3, 4, 5] ys = [randb, rap, classical, pop, indie] # setting range xrng = np.arange(len(xs)) yrng = np.arange(0, max(ys)+60, 50) #labeling data plt.xlabel('Music Type') plt.ylabel('Music volume') # spacing and declare bar chart plt.bar(xrng, ys, 0.45, align="center") # labeling plt.xticks(xrng, ["randb", "rap", "classical", "pop", "indie"]) plt.yticks(yrng) plt.grid(True) plt.show()
def plot_feature_importances_cancer(model, cancer): n_features = cancer.data.shape[1] plt.barh(np.arange(n_features), model.feature_importances_, align='center') plt.yticks(np.arange(n_features), cancer.feature_names) plt.xlabel("Feature importance") plt.ylabel("Feature") plt.ylim(-1, n_features)
def plot_3df( df, plot_title, x_axis, y_axis, plot, save ): # function for plotting high-dimension and low-dimension eigenvalues x1 = df[df.columns[0]] y1 = df[df.columns[1]] y2 = df[df.columns[2]] y3 = df[df.columns[3]] min1 = df[df.columns[1]].min() min2 = df[df.columns[2]].min() min3 = df[df.columns[3]].min() df_min = min(min1, min2, min3) plt.figure(figsize=(8, 8)) plt.plot(x1, y1, color='red') plt.plot(x1, y2, color='blue') plt.plot(x1, y3, color='green') plt.grid(color='black', linestyle='-', linewidth=0.1) # parameters for plot grid plt.xticks(np.arange(0, max(x1) * 1.1, int(max(x1) / 10))) # adjusting the intervals to 250 plt.yticks(np.arange(df_min * 0.9, 100, int(max(y1) / 10))) plt.title(plot_title).set_position([0.5, 1.05]) plt.xlabel(x_axis) plt.ylabel(y_axis) plt.legend(loc='best') # creating legend and placing in at the top right if save == 'yes': plt.savefig(plot_title) if plot == 'yes': plt.show() plt.close()
def print_save_all_mean_faces(x_class_mean, global_mean, show, save): rows = 4 cols = 14 index = 1 font_size = 10 plt.figure(figsize=(20, 10)) plt.subplot(rows, cols, index), plt.imshow(np.reshape(global_mean, (46, 56)).T, cmap='gist_gray') title = str("Global Mean") plt.title(title, fontsize=font_size).set_position([0.5, 0.95]), plt.xticks( []), plt.yticks([]) index = index + 1 for i in range(0, x_class_mean.shape[1]): title = str("Class Mean " + str(i + 1)) plt.subplot(rows, cols, index), plt.imshow(np.reshape(x_class_mean[:, i], (46, 56)).T, cmap='gist_gray') plt.title(title, fontsize=font_size).set_position( [0.5, 0.95]), plt.xticks([]), plt.yticks([]) index = index + 1 if show == 'yes': plt.show() if save == 'yes': plt.savefig('Global and Class Mean') plt.close()
def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues, filename='viz\\confusion_matrix.png'): plt.figure() plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45) plt.yticks(tick_marks, classes) if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] thresh = cm.max() / 2. for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])): plt.text(j, i, cm[i, j], horizontalalignment="center", color="white" if cm[i, j] > thresh else "black") plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') plt.savefig(filename)
def plotRetinaSpikes(retina=None, label=""): assert retina is not None, "Network is not initialised! Visualising failed." import matplotlib.pyplot as plt from matplotlib import animation print "Visualising {0} Spikes...".format(label) spikes = [x.getSpikes() for x in retina] # print spikes sortedSpikes = sortSpikes(spikes) # print sortedSpikes framesOfSpikes = generateFrames(sortedSpikes) # print framesOfSpikes x = range(0, dimensionRetinaX) y = range(0, dimensionRetinaY) from numpy import meshgrid rows, pixels = meshgrid(x,y) fig = plt.figure() initialData = createInitialisingData() imNet = plt.imshow(initialData, cmap='green', interpolation='none', origin='upper') plt.xticks(range(0, dimensionRetinaX)) plt.yticks(range(0, dimensionRetinaY)) args = (framesOfSpikes, imNet) anim = animation.FuncAnimation(fig, animate, fargs=args, frames=int(simulationTime)*10, interval=30) plt.show()
def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues): if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] print("Normalized confusion matrix") else: print("Confusion Matrix, without normalization") print(cm) #imshow displays data as an image on a 2d master plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() #returns evenly spaced values with a given inteerval tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45) plt.yticks(tick_marks, classes) fmt = '.2f' if normalize else 'd' thresh = cm.max() / 2. for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])): plt.text(j, i, format(cm[i, j], fmt), horizontalalignment='center', color='white' if cm[i, j] > thresh else "black") plt.tight_layout() plt.ylabel('True Label') plt.xlabel('Predicted Label')
def plot_confusion_matrix(cm, classes, normalize=False, title='Confusion matrix', cmap=plt.cm.Blues): """ This function prints and plots the confusion matrix. Normalization can be applied by setting `normalize=True`. """ plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() tick_marks = np.arange(len(classes)) plt.xticks(tick_marks, classes, rotation=45) plt.yticks(tick_marks, classes) if normalize: cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis] print("Normalized confusion matrix") else: print('Confusion matrix, without normalization') print(cm) thresh = cm.max() / 2. for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])): plt.text(j, i, cm[i, j], horizontalalignment="center", color="white" if cm[i, j] > thresh else "black") plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label')
def plot_sleep(label, pred, file_time, kfold, name): x = range(0, len(label)) y = np.arange(5) y_stage = ["W", "REM", "N1", "N2", "N3"] plt.figure(figsize=(24, 8)) plt.ylabel("Sleep Stage") plt.xlabel("Sleep Time") time_choice = np.array([ s.decode('UTF-8') for s in file_time[0:len(file_time):int(len(file_time) / 10)] ]) plt.xticks(range(0, len(file_time), int(len(file_time) / 10)), time_choice) ##为了将坐标刻度设为字 plt.yticks(y, y_stage) ##为了将坐标刻度设为字 # plot中参数的含义分别是横轴值,纵轴值,线的形状,颜色,透明度,线的宽度和标签 plt.plot(x, pred, 'r-', color='blue', alpha=1, linewidth=1, label='predict') plt.plot(x, label, 'r-', color='red', alpha=1, linewidth=1, label='label') plt.legend(loc='best') plt.savefig(sleepPicture_path + str(kfold) + "sdt" + str(name) + ".svg") ##保存睡眠模型图文件 plt.close()
def plot_classification_report(cr, title='Classification report ', with_avg_total=False, cmap=plt.cm.Blues): lines = cr.split('\n') classes = [] plotMat = [] for line in lines[2:(len(lines) - 3)]: #print(line) t = line.split() if len(t): classes.append(t[0]) v = [float(x) for x in t[1:len(t) - 1]] print(v) plotMat.append(v) if with_avg_total: aveTotal = lines[len(lines) - 1].split() classes.append('avg/total') vAveTotal = [float(x) for x in t[1:len(aveTotal) - 1]] plotMat.append(vAveTotal) plt.imshow(plotMat, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() x_tick_marks = np.arange(3) y_tick_marks = np.arange(len(classes)) plt.xticks(x_tick_marks, ['precision', 'recall', 'f1-score', 'support'], rotation=45) plt.yticks(y_tick_marks, classes) plt.tight_layout() plt.ylabel('Classes') plt.xlabel('Measures')
def plot_df( df1, df2, plot_title, x_axis, y_axis, plot, save ): # function for plotting high-dimension and low-dimension eigenvalues y1 = df1[df1.columns[1]] x1 = df1['M'] y2 = df2[df2.columns[1]] x2 = df2['M'] plt.figure(figsize=(8, 8)) plt.plot(x1, y1, color='red') plt.plot(x2, y2, color='blue') plt.grid(color='black', linestyle='-', linewidth=0.1) # parameters for plot grid plt.xticks(np.arange(0, max(x1) * 1.1, int(max(x1) / 10))) # adjusting the intervals to 250 plt.yticks(np.arange(0, max(y1) * 1.1, int(max(y1) / 10))) plt.title(plot_title).set_position([0.5, 1.05]) plt.xlabel(x_axis) plt.ylabel(y_axis) plt.legend(loc='best') # creating legend and placing in at the top right if save == 'yes': plt.savefig(plot_title) if plot == 'yes': plt.show() plt.close()
def silhouette(): if not os.path.exists("Stardust_results"): print( "The directory structure Stardust_results doest not exist. Please run run_stardust first" ) sys.exit() if not os.path.exists("Stardust_results/analysis"): os.mkdir("Stardust_results/analysis") output_path = "Stardust_results/analysis/" from sklearn.metrics import silhouette_samples, silhouette_score data_df = pd.read_csv( 'Stardust_results/visualization_output/3_pass/data.csv', delimiter=",", index_col=False) data_df.set_index('data', inplace=True) silhouette_avg = silhouette_score(data_df[['x', 'y']], data_df['cluster']) sample_silhouette_values = silhouette_samples(data_df[['x', 'y']], data_df['cluster']) print("silhouette score ", silhouette_avg) y_lower = 10 import matplotlib.cm as cm fig = plt.figure(figsize=(4, 7)) n_clusters = len(list(data_df['cluster'].unique())) for i in range(n_clusters): # Aggregate the silhouette scores for samples belonging to # cluster i, and sort them ith_cluster_silhouette_values = \ sample_silhouette_values[data_df['cluster'] == i] ith_cluster_silhouette_values.sort() size_cluster_i = ith_cluster_silhouette_values.shape[0] y_upper = y_lower + size_cluster_i color = cm.nipy_spectral(float(i) / n_clusters) plt.fill_betweenx(np.arange(y_lower, y_upper), 0, ith_cluster_silhouette_values, facecolor=color, edgecolor=color, alpha=0.7) # Label the silhouette plots with their cluster numbers at the middle plt.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i)) # Compute the new y_lower for next plot y_lower = y_upper + 10 # 10 for the 0 samples plt.title("The silhouette plot for the various clusters.") plt.xlabel("silhouette coefficient", fontsize=20) plt.ylabel("Cluster label", fontsize=20) plt.axvline(x=silhouette_avg, color="red", linestyle="--") plt.yticks([]) # Clear the yaxis labels / ticks plt.xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1]) sns.despine(bottom=False, left=False) fig.savefig(output_path + "/silhouette.pdf", bbox_inches='tight', dpi=600) fig.savefig(output_path + "/silhouette.png", bbox_inches='tight', dpi=600)
def plot_line(x, y, y_hat, line_color='blue'): # Plot outputs plt.scatter(x, y, color='black') plt.plot(x, y_hat, color=line_color, linewidth=3) plt.xticks(()) plt.yticks(()) plt.show()
def plot_gallery(images, titles, h, w, n_row=3, n_col=4): """Helper function to plot a gallery of portraits""" pl.figure(figsize=(1.8 * n_col, 2.4 * n_row)) pl.subplots_adjust(bottom=0, left=.01, right=.99, top=.90, hspace=.35) for i in range(n_row * n_col): pl.subplot(n_row, n_col, i + 1) pl.imshow(images[i].reshape((h, w)), cmap=pl.cm.gray) pl.title(titles[i], size=12) pl.xticks(()) pl.yticks(())
def plot_sample(x, title="", width=28, fName=None): fig = plt.figure() sample = x.reshape(width, width) # interploation can be 'nearest' to put grid at the center the pixels plt.imshow(sample, interpolation='None', cmap='gray') plt.title(title) plt.xticks([]) plt.yticks([]) if fName != None: savefig(fName, bbox_inches='tight') plt.show()
def cm_plot(original_label, predict_label, kunm, pic=None): prec_score = precision_score(original_label, predict_label, average=None) recall = recall_score(original_label, predict_label, average=None) f1 = f1_score(original_label, predict_label, average=None) cm = confusion_matrix(original_label, predict_label) cm_new = np.empty(shape=[5, 5]) for x in range(5): t = cm.sum(axis=1)[x] for y in range(5): cm_new[x][y] = round(cm[x][y] / t * 100, 2) plt.figure() plt.matshow(cm_new, cmap=plt.cm.Blues) plt.colorbar() x_numbers = [] y_numbers = [] cm_percent = [] for x in range(5): y_numbers.append(cm.sum(axis=1)[x]) x_numbers.append(cm.sum(axis=0)[x]) for y in range(5): percent = format(cm_new[x, y] * 100 / cm_new.sum(axis=1)[x], ".2f") cm_percent.append(str(percent)) plt.annotate(format(cm_new[x, y] * 100 / cm_new.sum(axis=1)[x], ".2f"), xy=(y, x), horizontalalignment='center', verticalalignment='center', fontsize=10) plt.ylabel('True label') plt.xlabel('Predicted label') plt.title('confusion matrix') y_stage = [ "W\n(" + str(y_numbers[0]) + ")", "N1\n(" + str(y_numbers[1]) + ")", "N2\n(" + str(y_numbers[2]) + ")", "N3\n(" + str(y_numbers[3]) + ")", "REM\n(" + str(y_numbers[4]) + ")" ] x_stage = [ "W\n(" + str(x_numbers[0]) + ")", "N1\n(" + str(x_numbers[1]) + ")", "N2\n(" + str(x_numbers[2]) + ")", "N3\n(" + str(x_numbers[3]) + ")", "REM\n(" + str(x_numbers[4]) + ")" ] y = [0, 1, 2, 3, 4] plt.xticks(y, x_stage) plt.yticks(y, y_stage) #sns.heatmap(cm_percent, fmt='g', cmap="Blues", annot=True, cbar=False, xticklabels=x_stage, yticklabels=y_stage) # 画热力图,annot=True 代表 在图上显示 对应的值, fmt 属性 代表输出值的格式,cbar=False, 不显示 热力棒 plt.savefig(savepath + "matrix" + str(kunm) + ".svg") #plt.show() plt.show() plt.close() # plt.savefig("/home/data_new/zhangyongqing/flx/pythoncode/"+str(knum)+"matrix.jpg") return kappa(cm), classification_report(original_label, predict_label)
def plot_sample_from_dataset(images, labels,rows=5, colums=5, width=8,height=8): plt.figure(figsize=(width,height)) for i in range(rows*colums): plt.subplot(rows,colums,i+1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(images[i], cmap=plt.cm.binary) plt.xlabel(labels[i]) plt.show()
def make_spider(self, df, row, title, color): """ Function which draw the radar charts of the clusters obtained with K-Means """ # number of variable categories = list(df)[1:] N = len(categories) # What will be the angle of each axis in the plot? (we divide the plot / number of variable) angles = [n / float(N) * 2 * pi for n in range(N)] angles += angles[:1] # Initialise the spider plot # fig, ax = plt.subplots(2, 2, row + 1, polar=True) fig = plt.figure() ax = fig.add_subplot(int(str(22) + str(row + 1)), polar=True) # If you want the first axis to be on top: ax.set_theta_offset(pi / 2) ax.set_theta_direction(-1) # Draw one axe per variable + add labels labels yet plt.xticks(angles[:-1], categories, color='black', size=8) # Draw ylabels ax.set_rlabel_position(0) plt.yticks([10, 20, 30], ["10", "20", "30"], color="black", size=7) plt.ylim(0, 40) # Ind1 values = df.loc[row].drop('group').values.flatten().tolist() values += values[:1] ax.plot(angles, values, color=color, linewidth=2, linestyle='solid') ax.fill(angles, values, color=color, alpha=0.4) # Add a title # plt.title(title, size=11, color=color, y=1.1) # ------- PART 2: Apply to all individuals # initialize the figure my_dpi = 96 plt.figure(figsize=(1000 / my_dpi, 1000 / my_dpi), dpi=my_dpi) # Create a color palette: my_palette = plt.cm.get_cmap("Set2", len(df.index)) # Loop to plot for row in range(0, len(df.index)): make_spider(row=row, title='group ' + df['group'][row], color=my_palette(row)) plt.show()
def cm_plot(original_label, predict_label, kunm, savepath): prec_score = precision_score(original_label, predict_label, average=None) recall = recall_score(original_label, predict_label, average=None) f1 = f1_score(original_label, predict_label, average=None) cm = confusion_matrix(original_label, predict_label) cm_new = np.empty(shape=[5, 5]) for x in range(5): t = cm.sum(axis=1)[x] for y in range(5): cm_new[x][y] = round(cm[x][y] / t * 100, 2) plt.figure() plt.matshow(cm_new, cmap=plt.cm.Blues) plt.colorbar() x_numbers = [] y_numbers = [] cm_percent = [] for x in range(5): y_numbers.append(cm.sum(axis=1)[x]) x_numbers.append(cm.sum(axis=0)[x]) for y in range(5): percent = format(cm_new[x, y] * 100 / cm_new.sum(axis=1)[x], ".2f") cm_percent.append(str(percent)) plt.annotate(format(cm_new[x, y] * 100 / cm_new.sum(axis=1)[x], ".2f"), xy=(y, x), horizontalalignment='center', verticalalignment='center', fontsize=10) plt.ylabel('True label') plt.xlabel('Predicted label') plt.title('confusion matrix') y_stage = [ "W\n(" + str(y_numbers[0]) + ")", "N1\n(" + str(y_numbers[1]) + ")", "N2\n(" + str(y_numbers[2]) + ")", "N3\n(" + str(y_numbers[3]) + ")", "REM\n(" + str(y_numbers[4]) + ")" ] x_stage = [ "W\n(" + str(x_numbers[0]) + ")", "N1\n(" + str(x_numbers[1]) + ")", "N2\n(" + str(x_numbers[2]) + ")", "N3\n(" + str(x_numbers[3]) + ")", "REM\n(" + str(x_numbers[4]) + ")" ] y = [0, 1, 2, 3, 4] plt.xticks(y, x_stage) plt.yticks(y, y_stage) plt.savefig(savepath + "matrix" + str(kunm) + ".svg") plt.show() plt.close() return kappa(cm), classification_report(original_label, predict_label)
def plot_feature_importances_cancer(scores): names, val_scores = [name for name, _, _, _, _, _, _ in scores ], [score for _, score, _, _, _, _, _ in scores] plt.rcParams["figure.figsize"] = [15, 9] n_features = len(names) plt.barh(range(n_features), val_scores, align='center') plt.yticks(np.arange(n_features), names) plt.xlabel("Accuracy") plt.ylabel("Model") path = WORKING_PATH + "/___comparison_cancer_model.png" plt.savefig(path) plt.clf() return path
def object_detection_api(img_path, threshold=0.5, rect_th=3, text_size=3, text_th=3): boxes, pred_cls = get_prediction(img_path, threshold) # Get predictions img = cv2.imread(img_path) # Read image with cv2 img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # Convert to RGB for i in range(len(boxes)): cv2.rectangle(img, boxes[i][0], boxes[i][1],color=(0, 255, 0), thickness=rect_th) # Draw Rectangle with the coordinates cv2.putText(img,pred_cls[i], boxes[i][0], cv2.FONT_HERSHEY_SIMPLEX, text_size, (0,255,0),thickness=text_th) # Write the prediction class plt.figure(figsize=(20,30)) # display the output image plt.imshow(img) plt.xticks([]) plt.yticks([]) plt.show()
def plot_value_array(i, predictions_array, true_label, number_of_classes=3): predictions_array, true_label = predictions_array, true_label[i] plt.style.use(['classic']) plt.grid(False) plt.xticks(range(number_of_classes)) plt.yticks([]) thisplot = plt.bar(range(number_of_classes), 1, color="#FFFFFF") plt.ylim([0, 1]) predicted_label = np.argmax(predictions_array) #print(true_label[0]) #print(predicted_label) thisplot[predicted_label].set_color('red') thisplot[true_label].set_color('blue')
def plot_confusion_matrix(cm, labels, title='Confusion matrix', cmap=plt.cm.Blues, save=False): plt.figure() plt.imshow(cm, interpolation='nearest', cmap=cmap) plt.title(title) plt.colorbar() tick_marks = np.arange(len(labels)) plt.xticks(tick_marks, labels, rotation=45) plt.yticks(tick_marks, labels) plt.tight_layout() plt.ylabel('True label') plt.xlabel('Predicted label') plt.show() if save: plt.savefig(save)
def dimension_reduction(method, dimension): my_arrays = load_data(0, get_avg=True) for i in range(1, 89): my_arrays = np.concatenate((my_arrays, load_data(i, get_avg=True)), axis=0) # print(my_arrays.shape) my_tensor = torch.from_numpy(my_arrays) my_labels = np.loadtxt('hist/rotation.txt') print(my_labels.shape) # time.sleep(30) color_choice = ['b', 'g', 'r', 'yellow'] # print(my_tensor) if method == 'tsne': module = manifold.TSNE(n_components=dimension, init='random', random_state=500, early_exaggeration=5, method='exact') elif method == 'PCA': module = PCA(n_components=3) x_numpy = my_tensor.data.cpu().numpy() x_reduced = module.fit_transform(x_numpy) print(x_reduced.shape) print(x_reduced) plt.figure() if dimension == 2: for i in range(x_reduced.shape[0]): color_index = int(my_labels[i]) plt.plot(x_reduced[i, 0], x_reduced[i, 1], 'o', color=color_choice[color_index]) plt.xticks() plt.yticks() elif dimension == 3: ax = plt.axes(projection='3d') for i in range(x_reduced.shape[0]): color_index = int(my_labels[i]) ax.scatter(x_reduced[i, 0], x_reduced[i, 1], x_reduced[i, 2], color=color_choice[color_index]) ax.set_xlabel('X Label') ax.set_ylabel('Y Label') ax.set_zlabel('Z Label') plt.savefig('plots/{}-24bin-{}d.pdf'.format(method, dimension)) plt.show()
def plotDisparityMap(network=None, disparity=0): assert network is not None, "Network is not initialised! Visualising failed." assert disparity >= 0 and disparity <= maxDisparity, "No such disparity map in the network." import matplotlib.pyplot as plt from matplotlib import animation from NetworkBuilder import sameDisparityInd print "Visualising results for disparity value {0}...".format(disparity) cellsOut = [network[x][2] for x in sameDisparityInd[disparity]] spikes = [x.getSpikes() for x in cellsOut] # print spikes sortedSpikes = sortSpikes(spikes) # print sortedSpikes framesOfSpikes = generateFrames(sortedSpikes) # print framesOfSpikes x = range(0, dimensionRetinaX) y = range(0, dimensionRetinaY) from numpy import meshgrid rows, pixels = meshgrid(x,y) fig = plt.figure() initialData = createInitialisingData() # print initialData imNet = plt.imshow(initialData, cmap='gray', interpolation='none', origin='upper') plt.xticks(range(0, dimensionRetinaX)) plt.yticks(range(0, dimensionRetinaY)) plt.title("Disparity Map {0}".format(disparity)) args = (framesOfSpikes, imNet) anim = animation.FuncAnimation(fig, animate, fargs=args, frames=int(simulationTime)*10, interval=30) plt.show()
plt.loglog(xr10/10,Nr10,'o',markersize=8,color=c1,label=r'$\sigma=0.10h_0$') plt.loglog(xr20/10,Nr20,'s',markersize=8,color=c1,label=r'$\sigma=0.20h_0$') plt.loglog(xr25/10,Nr25,'^',markersize=8,color=c1,label=r'$\sigma=0.25h_0$') plt.loglog(xr30/10,Nr30,'v',markersize=8,color=c1,label=r'$\sigma=0.30h_0$') plt.loglog(xr40/10,Nr40,'<',markersize=8,color=c1,label=r'$\sigma=0.40h_0$') plt.loglog(xr50/10,Nr50,'>',markersize=8,color=c1,label=r'$\sigma=0.50h_0$') plt.loglog(xg2/10,Ng2,'d',markersize=8,color=c2,label=r'$\gamma=0.2l_p$') plt.loglog(xg4/10,Ng4,'o',markersize=8,color=c2,label=r'$\gamma=0.4l_p$') plt.loglog(xg10/10,Ng10,'s',markersize=8,color=c2,label=r'$\gamma=l_p$') plt.loglog(xg20/10,Ng20,'^',markersize=8,color=c2,label=r'$\gamma=2l_p$') plt.loglog(xg40/10,Ng40,'v',markersize=8,color=c2,label=r'$\gamma=4l_p$') plt.loglog(xg100/10,Ng100,'<',markersize=8,color=c2,label=r'$\gamma=10l_p$') plt.loglog(xg1000/10,Ng1000,'>',markersize=8,color=c2,label=r'$\gamma=100l_p$') plt.legend(loc='upper right',prop={'size':17}) plt.xticks((10**0, 10**1, 10**2), (r'$10^{0}$', r'$10^{1}$', r'$10^{2}$'), fontsize=24) plt.yticks((10**0, 10**1, 10**2, 10**3), (r'$10^{0}$', r'$10^{1}$', r'$10^{2}$', r'$10^{3}$'), fontsize=24) ax = plt.gca() ax.tick_params(axis='both',reset=False,which='both',length=10,width=2,direction='bottom') ax.yaxis.set_tick_params(length=20,width=2,direction='bottom') ax.xaxis.set_tick_params(length=20,width=2,direction='bottom') ax.tick_params(axis='both',reset=False,which='minor',length=10,width=1,direction='bottom') ax.xaxis.set_tick_params(length=20,width=1,direction='bottom') ax.yaxis.set_tick_params(length=20,width=1,direction='bottom') plt.annotate(r'$N_{LSA}=173$', fontsize=24, xy=(6, 173), xytext=(9,173), horizontalalignment='left', verticalalignment='center', arrowprops=dict(facecolor='black', shrink=0.05)) plt.xlabel(r'$\mathit{L_w/l_p}$',fontsize=24) plt.ylabel(r'$\mathit{N(L_{w})}$',fontsize=24) l1 = [3,80] l2 = [80,3] scatter(l1,l2) plot(l1,l2,color='black',linewidth=4) plt.yticks((10**0, 10**1, 10**2, 10**3), (r'$10^{0}$', r'$10^{1}$', r'$10^{2}$', r'$10^{3}$'), fontsize=24)
diabetes_y_train = diabetes.target[:-20] diabetes_y_test = diabetes.target[-20:] regr = linear_model.LinearRegression() regr.fit(diabetes_X_train, diabetes_y_train) # >> LinearRegression(copy_X=True, fit_intercept=True, normalize=False) print regr.coef_ # The mean square error np.mean((regr.predict(diabetes_X_test)-diabetes_y_test)**2) # Explained variance score: 1 is perfect prediction # and 0 means that there is no linear relationship # between X and Y. regr.score(diabetes_X_test, diabetes_y_test) # Plot results pl.clf() # Clear plots pl.plot(diabetes_X_test, regr.fit(diabetes_X_train, diabetes_y_train)); pl.title('Linear regression of sample diabetes data\n' 'Centroids are marked with white cross') pl.xlim(x_min, x_max) pl.ylim(y_min, y_max) pl.xticks(()) pl.yticks(()) pl.show()
x = (df['west'] - df['west'].min())*477/(df['east'].max() - df['west'].min()) y = 798-(df['north'] - df['south'].min())*798/(df['north'].max() - df['south'].min()) s = df['currentspeed'] / df['currentspeed'].max() plt.scatter(x,y,c=s,linewidth=0,s=1000,alpha=0.1) #x0 = (df.ix[0]['west'] - df['west'].min())*477/(df['east'].max() - df['west'].min()) #y0 = 798-(df.ix[0]['north'] - df['south'].min())*798/(df['north'].max() - df['south'].min()) #plt.scatter(x0,y0,c='r',s=2000) #x0 = (df.ix[0]['east'] - df['west'].min())*477/(df['east'].max() - df['west'].min()) #y0 = 798-(df.ix[0]['south'] - df['south'].min())*798/(df['north'].max() - df['south'].min()) #plt.scatter(x0,y0,c='r',s=2000) plt.xlim(0,477) plt.ylim(798,0) plt.xticks([]) plt.yticks([]) #plt.plot([df['west'],df['west'],df['east'],df['east'],df['west']],[df['south'],df['north'],df['north'],df['south'],df['south']],linewidth=20,alpha=0.2) # <codecell> plt.figure(figsize=(15,15)) patches = [] verts = [(df['west'],df['south']), (df['west'],df['north']), (df['east'],df['north']), (df['east'],df['south']), (df['west'],df['south'])] codes = [Path.MOVETO, Path.LINETO,
def create_figure_surface(figid, aspect, xx, yy, cmin, cmax, levels, slices, v3d): ''' creates a plot of the surface of a tracer data Parameters ---------- figid : int id of figure aspect: float aspect ratio of figure xx : array scale of x axis yy : array scale of y axis cmin,cmax : array minimum and maxminm of the color range levels : array range of contourlines slices : array location of slices v3d : vector data in geometry format Returns ------- plot : of surface data ''' # prepare matplotlib import matplotlib matplotlib.rc("font",**{"family":"sans-serif"}) matplotlib.rc("text", usetex=True) #matplotlib.use("PDF") import matplotlib.pyplot as plt # basemap from mpl_toolkits.basemap import Basemap # numpy import numpy as np # data vv = v3d[0,:,:,0] # shift vv = np.roll(vv, 64, axis=1) # plot surface plt.figure(figid) # colormap cmap = plt.cm.bone_r # contour fill p1 = plt.contourf(xx, yy, vv, cmap=cmap, levels=levels, origin="lower")#, hold="on") plt.clim(cmin, cmax) # contour lines p2 = plt.contour(xx, yy, vv, levels=levels, linewidths = (1,), colors="k")#, hold="on") plt.clabel(p2, fmt = "%2.1f", colors = "k", fontsize = 14) #plt.colorbar(p2,shrink=0.8, extend='both') # slices #s1 = xx[np.mod(slices[0]+64, 128)] #s2 = xx[np.mod(slices[1]+64, 128)] #s3 = xx[np.mod(slices[2]+64, 128)] # print s1, s2, s3 #plt.vlines([s1, s2, s3], -90, 90, color='k', linestyles='--') # set aspect ratio of axes plt.gca().set_aspect(aspect) # basemap m = Basemap(projection="cyl") m.drawcoastlines(linewidth = 0.5) # xticks plt.xticks(range(-180, 181, 45), range(-180, 181, 45)) plt.xlim([-180, 180]) plt.xlabel("Longitude [degrees]", labelpad=8) # yticks plt.yticks(range(-90, 91, 30), range(-90, 91, 30)) plt.ylim([-90, 90]) plt.ylabel("Latitude [degrees]") # write to file plt.savefig("solution-surface", bbox_inches="tight") plt.show()