def main(): df = pd.read_csv('fishiris.csv') df['target'] = df.apply(create_target, axis=1) y = df['target'].to_numpy() df = df.drop(['Name', 'target'], axis=1) feature_names = df.columns.tolist() X = df.to_numpy() target_names = ['setosa', 'versicolor', 'virginica'] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, shuffle=True) print('X_train\n', X_train) print('y_train\n', y_train) print('X_test\n', X_test) print('y_test\n', y_test) clf = ClassificationTree() clf.fit(X_train, y_train) y_pred = clf.predict(X_test) print('-' * 40, 'print_tree', '-' * 40) clf.print_tree(feature_names=feature_names) print('-' * 40, 'print_tree', '-' * 40) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) Plot().plot_in_2d(X_test, y_pred, title="Decision Tree", accuracy=accuracy, legend_labels=target_names) Plot().plot_in_3d(X_test, y_pred)
def strengthPlot(self): # set colorMap maxStrength = utils.ceilToRoundNumber(np.max(self.spring)) jet = plt.get_cmap('Blues') cNorm = colors.Normalize(vmin = 0, vmax = maxStrength) colorMap = cmx.ScalarMappable(norm=cNorm, cmap=jet) # calculate relevant properties xpos = self.initialPos.x ypos = self.initialPos.y # plot fig = plt.figure(facecolor=(1,1,1), figsize=(10, 6), dpi=150) ax = fig.add_axes([0.05, 0.10, 0.85, 0.8]) for i,j in itertools.product(range(len(xpos)), range(len(ypos))): if self.connections[i,j]: colorVal = colorMap.to_rgba(self.spring[i,j]) plt.plot([xpos[i], xpos[j]], [ypos[i], ypos[j]], color = colorVal) plt.plot(xpos, ypos, 'ko', markersize = 10) plt.fill_between([-12, 12], -20, 0, facecolor='gray', edgecolor='gray') plt.axis('off') Plot.configurePlot(fig, ax, "","", False) ax.set_xlim( xmin = -14, xmax = 14) ax.set_ylim( ymin = -5, ymax = 15) # Add colorbar, make sure to specify tick locations to match desired ticklabels cax = fig.add_axes([0.90, 0.10, 0.02, 0.8]) cbar = clb.ColorbarBase(cax, cmap = jet, ticks=[0,0.25,0.5,0.75,1]) cbar.ax.set_yticklabels(['0', str(maxStrength / 4),str(maxStrength / 2 ), str(maxStrength/4 * 3), str(maxStrength) ]) # vertically oriented colorbar cbar.ax.tick_params(labelsize = 14) cbar.ax.set_ylabel('Spring Constant', rotation=270) Plot.save2eps(fig, 'strengthPlot')
def plot(self , title = 'Training Scores', show = True): """ generate a plot of the training""" fig, ax = Plot.initPlot() for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] + ax.get_xticklabels() + ax.get_yticklabels()): item.set_fontsize(17) self.generatePlot() plt.title(title + " optimum = " + num2str(self.optimalscore) ) # EXTEND automatic names Plot.configurePlot(fig, ax, 'Temp', 'Temp', legend = True, legendLocation = 'lower center') plt.xlabel(self.xlabel) plt.ylabel('Distance Traveled') # TODO generalize if show: plt.show()
def main(): # Load dataset data = datasets.load_iris() # X = normalize(data.data[data.target != 0]) X = data.data[data.target != 0] y = data.target[data.target != 0] y[y == 1] = 0 y[y == 2] = 1 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.333) clf = LogisticRegression(iteration=10) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) y_pred = np.reshape(y_pred, y_test.shape) accuracy = roc_auc_score(y_test, y_pred) print("Accuracy:", accuracy) y_pred = clf.predict_label(X_test) report = classification_report(y_test, y_pred) print(report) # Reduce dimension to two using PCA and plot the results Plot().plot_in_2d(X_test, y_pred, title="Logistic Regression", accuracy=accuracy)
def main(): data = datasets.load_digits() X = normalize(data.data) y = data.target # convert the nominal y values to binary y = to_categorical(y) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4) #mlp clf = MultilayerPerceptron(n_hidden=16, n_iterations=1000, learning_rate=0.01) clf.fit(X_train, y_train) y_pred = np.argmax(clf.predict(X_test), axis=1) y_test = np.argmax(y_test, axis=1) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) # Reduce dimension to two using PCA and plot the results Plot().plot_in_2d(X_test, y_pred, title="Multilayer Perceptron", accuracy=accuracy, legend_labels=np.unique(y))
def main(): # Load dataset data = datasets.load_iris() X = normalize(data.data[data.target != 0]) y = data.target[data.target != 0] y[y == 1] = 0 y[y == 2] = 1 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, seed=1) clf = LogisticRegression() clf.fit(X_train, y_train) y_pred = clf.predict(X_test) y_pred = np.reshape(y_pred, y_test.shape) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) # Reduce dimension to two using PCA and plot the results Plot().plot_in_2d(X_test, y_pred, title="Logistic Regression", accuracy=accuracy, legend_labels=data.target_names)
def main(): data = datasets.load_digits() X = data.data y = data.target X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, seed=2) print("X_train.shape:", X_train.shape) print("Y_train.shape:", y_train.shape) clf = RandomForest(n_estimators=100) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) Plot().plot_in_2d(X_test, y_pred, title="Random Forest", accuracy=accuracy, legend_labels=data.target_names)
def main(): data = datasets.load_digits() X = normalize(data.data) y = data.target # One-hot encoding of nominal y-values y = to_categorical(y) X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33, seed=8) # Perceptron clf = Perceptron(n_iterations=5000, learning_rate=0.001, loss=CrossEntropy, activation_function=Sigmoid) clf.fit(X_train, y_train) y_pred = np.argmax(clf.predict(X_test), axis=1) y_test = np.argmax(y_test, axis=1) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) # Reduce dimension to two using PCA and plot the results Plot().plot_in_2d(X_test, y_pred, title="Perceptron", accuracy=accuracy, legend_labels=np.unique(y))
def plot(self, targetnum = 0, block = False): noTrain = len(self.trainTarget[targetnum]) noTest = len(self.testTarget[targetnum]) x1= np.arange(noTrain) * self.simulEnv.timeStep x2 = (noTrain + np.arange(noTest)) * self.simulEnv.timeStep fig, ax = Plot.initPlot() ax.set_title(r'$ \epsilon_{train} = %(num1)s \ \ \ \epsilon_{test} = %(num2)s $' % {'num1': num2str(self.trainRelError), 'num2': num2str(self.testRelError)}, fontsize = 30) ax.plot(np.hstack((x1,x2)), np.hstack((self.trainTarget[targetnum], self.testTarget[targetnum])), label = "target", linewidth = 3, alpha = 0.5) ax.plot(x1, self.trainOutput[targetnum], 'k-', label = "train") ax.plot(x2, self.testOutput[targetnum], 'r.', label = "test") ax.legend() Plot.configurePlot(fig,ax,"time","value", legendLocation = 'lower center') plt.show(block = block) return fig, ax
def plot(self, title='Training Scores', show=True): """ generate a plot of the training""" fig, ax = Plot.initPlot() for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] + ax.get_xticklabels() + ax.get_yticklabels()): item.set_fontsize(17) self.generatePlot() plt.title(title + " optimum = " + num2str(self.optimalscore)) # EXTEND automatic names Plot.configurePlot(fig, ax, 'Temp', 'Temp', legend=True, legendLocation='lower center') plt.xlabel(self.xlabel) plt.ylabel('Distance Traveled') # TODO generalize if show: plt.show()
def painted_point_cloud(calib_path,img_path,lidar_path,out_path,num): print('Now tracking num:',num) calib_path = calib_path + str(num).zfill(6)+ '.txt' img_path = img_path+ str(num).zfill(6) + '.png' lidar_path = lidar_path + str(num).zfill(6) +'.bin' out_path = out_path + str(num).zfill(6) +'.npy' raw_pointcloud =load_velo_scan(lidar_path) calib = calibration_kitti.Calibration(calib_path) img = cv2.imread(img_path) img_shape = img.shape pts_img,pts_rect_depth = calib.lidar_to_img(raw_pointcloud) # [N,3] in lidar to [N,2] in img pts_img = np.round(pts_img).astype(int)#四舍五入 #after lidar to img,filtering points in img's range ; val_flag_1 = np.logical_and(pts_img[:, 0] >= 0, pts_img[:, 0] < img_shape[1]) val_flag_2 = np.logical_and(pts_img[:, 1] >= 0, pts_img[:, 1] < img_shape[0]) val_flag_merge = np.logical_and(val_flag_1, val_flag_2) pts_valid_flag = np.logical_and(val_flag_merge, pts_rect_depth >= 0) ## in img's range ;all lidar points pts_img = pts_img[pts_valid_flag] pts_img[:, [0, 1]] = pts_img[:, [1, 0]]# height,width to width height[1242,375] to [375,1242] row = pts_img[:,0] col = pts_img[:,1] ''' for i in range(1,img_shape[0]-1): for j in range(1,img_shape[1]-1): #print('before:',img[i,j]) img[i,j] = (img[i-1,j-1]+img[i,j-1]+img[i+1,j-1]+img[i-1,j]+img[i+1,j]+img[i-1,j+1]+img[i,j+1]+img[i+1,j+1] +img[i,j])/9. #img[i,j] = (img[i, j - 1] + img[i - 1, j]+img[i,j]) / 3. #print('after,',img[i, j]) ''' img = img.astype(int) raw_pointcloud_color = img[row,col,:] # [N,3] b g r raw_pointcloud_color[:,[0,1,2]] = raw_pointcloud_color[:,[2,1,0]] painted_point_cloud_res = np.hstack((raw_pointcloud[pts_valid_flag],raw_pointcloud_color)) # [N,6] x,y,z,r,g,b Plot.draw_pc(painted_point_cloud_res) np.save(out_path,painted_point_cloud_res) return painted_point_cloud_res
def main(): data = loadDataSet('../x_train.csv') label = loadLabel('../y_train.csv') # tiaocan(data,label) X_train, X_test, y_train, y_test = train_test_split(data, label, test_size=0.4, seed=19260817) print("X_train.shape:", X_train.shape) print("Y_train.shape:", y_train.shape) clf = RandomForest(n_estimators=35) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) m = len(y_test) tp = 0.0 fp = 0.0 fn = 0.0 print(y_test) print(y_pred) for i in range(m): if y_pred[i] > 1 and y_test[i] > 1: tp += 1 if y_pred[i] < 1 and y_test[i] > 1: fp += 1 if y_pred[i] > 1 and y_test[i] < 1: fn += 1 precision = tp / (tp + fp) recall = tp / (tp + fn) f1_score = 2 * precision * recall / (precision + recall) print(tp, fp, fn) print("precision is: ", precision) print("recall is: ", recall) print("f1 score is: ", f1_score) Plot().plot_in_2d( X_test, y_pred, title="Random Forest") #accuracy=accuracy,#legend_labels=data.target_)
def main(): #load the dataset data = datasets.load_iris() X = data.data y = data.target #three -> two classes X = X[y != 2] y = y[y != 2] X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.2) #fit and predict using LDA lda = LDA() lda.fit(X_train, y_train) y_pred = lda.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print("accuracy:",accuracy) Plot().plot_in_2d(X_test, y_pred,title="LDA", accuracy=accuracy)
def main(): print ('-- Grandient Boosting Classification --') data = datasets.load_iris() X = data.data y = data.target X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4) clf = GBDTClassifier() clf.fit(X_train, y_train) y_pred = clf.predict(X_test) accuracy = accuracy_score(y_test,y_pred) print ('Accuracy:',accuracy) Plot().plot_in_2d(X_test, y_pred, title='GB', accuracy=accuracy, legend_labels=data.target_names)
def run(): data = datasets.load_iris() X = normalize(data.data) y = data.target X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33) #初始化knn model = KNN(k=5) y_pred = model.predict(X_test, X_train, y_train) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) # 用图画出测试集的分类情况 Plot().plot_in_2d(X_test, y_pred, title="KNN", accuracy=accuracy, legend_labels=data.target_names)
def main(): data = datasets.load_digits() X = normalize(data.data) y = data.target X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4) clf = NaiveBayes() clf.fit(X_train, y_train) y_pred = clf.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) #reduce dimension to two using PCA and plot the results Plot().plot_in_2d(X_test, y_pred, title="Naive Bayes", accuracy=accuracy, legend_labels=data.target_names)
def main(): print("-- classification Tree --") data = datasets.load_iris() X = data.data y = data.target import pdb #pdb.set_trace() X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4) #clf = ClassificationTree(min_samples_split=5,min_impurity=0.05,max_depth=5,criterion="entropy") clf = ClassificationTree(min_impurity=0.05, criterion="gini") clf.fit(X_train, y_train) y_pred = clf.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) Plot().plot_in_2d(X_test, y_pred, title="Decision Tree", accuracy=accuracy, legend_labels=data.target_names)
def main(): print("--XGBoost--") data = datasets.load_iris() X = data.data y = data.target X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4) clf = XGBoost(n_estimators=200, max_depth=3) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) Plot().plot_in_2d(X_test, y_pred, title="XGBoost", accuracy=accuracy, legend_labels=data.target_names)
def main(): print ("-- Classification Tree --") data = datasets.load_iris() X = data.data y = data.target X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4) clf = ClassificationTree() clf.fit(X_train, y_train) y_pred = clf.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print ("Accuracy:", accuracy) Plot().plot_in_2d(X_test, y_pred, title="Decision Tree", accuracy=accuracy, legend_labels=data.target_names)
def main(): # Load dataset data = datasets.load_iris() X = normalize(data.data[data.target != 0]) y = data.target[data.target != 0] y[y == 1] = 0 y[y == 2] = 1 X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3) clf = LogisticRegression(opt_type="SGD", gradient_descent=False) clf.fit(X_train, y_train) y_pred = clf.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print("Accuracy:", accuracy) # Reduce dimension to two using PCA and plot the results Plot().plot_in_2d(X_test, y_pred, title="Logistic Regression", accuracy=accuracy)
def main(): print("-- Gradient Boosting Classification --") data = load_iris() X = data.data y = data.target X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4) #print(y_train) clf = GBDTClassifier() clf.fit(X_train, y_train) y_pred = clf.predict(X_test) accuracy = accuracy_score(y_test, y_pred) print ("Accuracy:", accuracy) Plot().plot_in_2d(X_test, y_pred, title="Gradient Boosting", accuracy=accuracy, legend_labels=data.target_names) print('Done!')
def run(self): plot = Plot(num_subplots=2, subplot_title=["average score", "entropy"]) average_score = 0.0 average_entropy = 0.0 for episode in range(1, self.num_episodes+1): state = self.env.reset() state = state[np.newaxis, ...] done, score = False, 0 states, actions, rewards, probs, values, dones = [], [], [], [], [], [] while not done: if self.render_period > 0 and episode % self.render_period == 0: self.env.render() state = state.astype(np.float64) action, prob, value = self.act(state) next_state, reward, done, _ = self.env.step(action) states.append(state) actions.append(action) rewards.append(reward) dones.append(done) probs.append(prob) values.append(value) state = next_state[np.newaxis, ...] score += reward if done: loss_actor, loss_critic, entropy = self.replay(states, actions, rewards, probs, values, dones, next_state) average_score, self.scores = self.update_average(self.scores, score) average_entropy, self.entropies = self.update_average(self.entropies, entropy) print("episode: {}/{}, score: {:.2f}, average: {:.2f} loss actor={:.4f} critic={:.4f} entropy={:.4f} num states={}" .format(episode, self.num_episodes, score, average_score, loss_actor, loss_critic, average_entropy, len(states))) if self.plot: plot.update(value=average_score, idx=0) plot.update(value=average_entropy, idx=1) if average_score >= self.env.spec.reward_threshold: print(f"solved in {episode} episodes") break
#============================================================================ # Plot reweighted data #============================================================================ weights_train = [weight_trainEst10, weight_trainEst20, weight_trainEst40] weights_train_names = [ "weight_trainEst10", "weight_trainEst20", "weight_trainEst40" ] ### Training data for w, wn in zip(weights_train, weights_train_names): fig, ax = plt.subplots(2, 2, figsize=(15, 10)) ax = ax.flatten() fig, ax[0] = Plot(Histogram(data_train['muo_eta'][trainMask], data_train["label"][trainMask], w, 120, -4, 4), fig, ax[0], r"$\eta$", includeN=True) fig, ax[1] = Plot(Histogram(data_train['muo_pt'][trainMask], data_train["label"][trainMask], w, 120, -5, 120000), fig, ax[1], "pt", includeN=False) fig, ax[2] = Plot(Histogram( data_train['correctedScaledAverageMu'][trainMask], data_train["label"][trainMask], w, 80, -2, 80), fig, ax[2], r"$\langle\mu\rangle$",
def plot(self): fig, ax = Plot.initPlot() ax.plot(self.xdata,self.ydata) Plot.configurePlot(fig,ax, "time","current SpringLength") fig.show()
draw_hump(p, (x, y), radius, True) x += 2 * radius p.lineto(100, y) def main(p): num_colors = 2 num_rows = 20 color_assignments = [] last_color = 1 for r in range(num_rows): cur_color = random.randint(1, num_colors) while cur_color == last_color: cur_color = random.randint(1, num_colors) last_color = cur_color color_assignments.append(cur_color) for color in range(1, num_colors + 1): draw_color(p, num_rows, color_assignments, color) p.penup() input() if __name__ == '__main__': p = Plot() p.plot_size = 4 p.plotter_enabled = False p.setup() main(p) p.done()
t = t2 - t1 non_ground_index = np.where(segmentation[:, -1] == 0)[0] points_up = segmentation[non_ground_index][:, :] ground_index = np.where(segmentation[:, -1] != 0)[0] points_down = segmentation[ground_index][:, :] points_down_labels = points_down[:, 3] points_up_labels = points_up[:, 3] else: print('Method have not release') return None, None, None, None, 0 return points_up, points_up_labels, points_down, points_down_labels, t have_label = True method = 4 infile_path = '../data/velodyne/000002.npy' raw_data = reader.load_velo_scan(infile_path) if have_label: label_path = '../data/label/000002.npy' raw_label = np.load(label_path) else: raw_label = np.zeros((raw_data.shape[0], 1)) + 1 fileter_height, fileter_height_label, ground, fileter_height_label_ground, t = filter_ground( raw_data, raw_label, method) Plot.draw_pc_sem_ins(fileter_height, fileter_height_label)
label="Signal reweighted") ax[i].set(xlim=(edges_sig[0], edges_sig[-1]), xlabel=xlab, ylabel=f"Events/{bw:4.2f}") ax[i].legend() else: for i, (var, bin, rang, xlab) in enumerate( zip(variables, bins, ranges, xlabel)): fig, ax[i] = Plot(Histogram( data_train[var][mask], data_train["label"][mask], data_train[weightType + "_" + weightName][mask], bin, rang[0], rang[1]), fig, ax[i], xlab, includeN=True) #fig, ax[1] = Plot(Histogram(data_train['pt'][mask], data_train["label"][mask], data_train[weightType+"_"+weightName][mask], 120, -5, 120), fig, ax[1], "pt", includeN = False) #fig, ax[2] = Plot(Histogram(data_train['invM'][mask], data_train["label"][mask], data_train[weightType+"_"+weightName][mask], 120, 50, 110), fig, ax[2], "invM", includeN = False) #fig, ax[3] = Plot(Histogram(data_train['correctedScaledAverageMu'][mask], data_train["label"][mask], data_train[weightType+"_"+weightName][mask], 80, -2, 80), fig, ax[3], r"$\langle\mu\rangle$", includeN = False) counts_weight, edges_weight = np.histogram( data_train[weightType + "_" + weightName][mask], bins=120, range=(0, 40)) ax[4].step(x=edges_weight, y=np.append(counts_weight, 0), where="post", color="k")
#Data location #Images img_folderpath = '../data/KITTI/2011_09_26/image_02/data/*.png' img_filepaths = sorted(glob.glob(img_folderpath)) #Lidar lidar_folderpath = '../data/KITTI/2011_09_26/velodyne_points/data/*.bin' lidar_filepaths = sorted(glob.glob(lidar_folderpath)) #Yolo Network labelsPath = "../data/YOLO/coco.names" weightsPath = "../data/YOLO/yolov3.weights" configPath = "../data/YOLO/yolov3.cfg" modelPath = "../data/YOLO/yolov3_model.h5" #Loop over all data sequence dataBuffer = [] plot_results = Plot() view = View() LP = LidarProcessing() CP = CameraProcessing() #YOLO params = dict() params["confidence"] = 0.2 params["threshold"] = 0.4 params["shrink"] = 0.1 #LiDAR #Kitti x_range, y_range, z_range, scale = (-20, 20), (-20, 20), (-2, 2), 10 v_fov, h_fov, max_d = (-24.9, 2.0), (-90, 90), 70 #Udacity
def plot(self, spring = False): "make a 3D plot of the current morphology" # plot settings fig = plt.figure(facecolor='white', figsize = (10, 4)) if self.environment.threeD: ax = fig.gca(projection='3d') ax.set_zlabel('Z axis') ax.view_init(azim=-90, elev=90) else: ax = fig.gca() ax.set_xlabel('X axis') ax.set_ylabel('Y axis') radius = 0.3 def createSpring(xStart, yStart, xEnd, yEnd): radius = 0.5 xLen = xEnd - xStart yLen = yEnd - yStart len = np.sqrt(xLen ** 2 + yLen** 2) # Rescale xStartNew = xStart + radius * xLen / len yStartNew = yStart + radius * yLen / len xEndNew = xEnd - radius * xLen / len yEndNew = yEnd - radius * yLen / len xLen = xStartNew - xEndNew yLen = yStartNew - yEndNew len = np.sqrt(xLen ** 2 + yLen** 2) heightRatio = 2 twistLen = 0.15 linewidth = 2 noTwist = int(len / twistLen) xSpace = (xEndNew - xStartNew) * 1.0 / (noTwist) ySpace = (yEndNew - yStartNew) * 1.0 / (noTwist) X = [xStart, xStartNew] Y = [yStart, yStartNew] for i in range(noTwist): X.append((i + 0.5) * xSpace + xStartNew + (-1)**i * ySpace * heightRatio ) Y.append((i + 0.5) * ySpace + yStartNew - (-1)**i * xSpace * heightRatio ) X.append(xEndNew) X.append(xEnd) Y.append(yEndNew) Y.append(yEnd) plt.plot(X,Y, 'k', linewidth = linewidth) # plot lines for i, j in itertools.product(range(self.noNodes), range(self.noNodes)): if i < j and self.connections[i,j]: mat = np.array([self.initialPos.get(i), self.initialPos.get(j)]) if np.shape(mat)[1] == 3: ax.plot(mat[:,0], mat[:,1], mat[:,2]) elif spring: createSpring(mat[0,0], mat[0,1], mat[1,0], mat[1,1] ) else: ax.plot(mat[:,0], mat[:,1]) if np.shape(mat)[1] == 3: ax.plot(self.initialPos.x, self.initialPos.y, self.initialPos.z, 'k.', markersize = 10) else: Plot.circles(self.initialPos.x, self.initialPos.y, radius, 'k') if self.environment.threeD: xmin , xmax = ax.get_xlim3d() margin = 1 xmin -= margin xmax += margin x = np.expand_dims( np.arange(xmin, xmax), axis =0) z = np.expand_dims( np.arange(xmin, xmax), axis = 1) X = np.tile(x,np.shape(z)) Z = np.tile(z,np.shape(x)) Y = np.zeros_like(Z) Plot.setAxes3Dplot(ax, *ax.get_xlim3d()) # not general ax.plot_surface(X, Y, Z, rstride=400, cstride=400, color='#EEEEEE',shade = False) else: Plot.setAxes2Dplot(0.25) plt.axis("equal") plt.tight_layout(pad = 0) plt.axis('off') plt.show() return fig, ax
log.info("Saving test data to {}".format(filename_test)) with h5py.File(filename_test, 'w') as hf: for var in column_names: hf.create_dataset( f'{var}', data=np.array(data_test[var]), chunks=True, maxshape= (None,), compression='lzf') #============================================================================ # Plot reweighted data #============================================================================ weights_train = [weight_trainEst10, weight_trainEst20, weight_trainEst40] weights_train_names = ["weight_trainEst10", "weight_trainEst20", "weight_trainEst40"] ### Training data for w, wn in zip(weights_train, weights_train_names): fig, ax = plt.subplots(2,2,figsize=(15,10)) ax = ax.flatten() fig, ax[0] = Plot(Histogram(data_train['pho_eta'][trainMask], data_train["label"][trainMask], w, 120, -4, 4), fig, ax[0], r"$\eta$", includeN = True) ax[0].set_yscale('log') fig, ax[1] = Plot(Histogram(data_train['pho_et'][trainMask], data_train["label"][trainMask], w, 90, 0, 50), fig, ax[1], r"$E_T$", includeN = False) ax[1].set_yscale('log') fig, ax[2] = Plot(Histogram(data_train['correctedScaledActualMu'][trainMask], data_train["label"][trainMask], w, 90, 0, 90), fig, ax[2], r"$\langle\mu\rangle$", includeN = False) ax[2].set_yscale('log') counts_weight, edges_weight = np.histogram(w, bins=120, range=(0, 40)) ax[3].step(x=edges_weight, y=np.append(counts_weight, 0), where="post", color = "k"); ax[3].set_yscale('log', nonposy='clip') ax[3].set(xlabel = wn, ylabel = "Events per bin") fig.savefig(args.outdir + "train_reweighted" + wn + ".pdf") ### Validation data weights_valid = [weight_validEst10, weight_validEst20, weight_validEst40]
def run(self): plot = Plot(num_subplots=2, subplot_title=["average score", "entropy"]) if self.render_period > 0: r = self.render() print(f"reward={r}") for episode in range(self.num_episodes): states_history = [] actions_history = [] critic_values_history = [] action_probs_history = [] rewards_history = [] episode_steps = 0 done = False t_start = time.time() state = self.env.reset() self.policy.reset_states() episode_reward = 0 episode += 1 # play and record states, actions, action probabilities, rewards with tf.GradientTape() as tape: while not done: # state shape is (number_of_timesteps, state_size) with number_of_timesteps=1 state = state[np.newaxis, ...] action, action_probs, critic_value = self.action(state) next_state, reward, done, _ = self.env.step(action) states_history.append(state) actions_history.append(action) rewards_history.append(reward) # using index 0 because of output batch size of 1 action_probs_history.append(action_probs[0]) critic_values_history.append(critic_value[0]) state = next_state episode_reward += reward episode_steps += 1 # train policy with recorded values actor_loss, critic_loss = self.replay(actions_history, action_probs_history, critic_values_history, rewards_history) loss = actor_loss + critic_loss grads = tape.gradient(loss, self.policy.trainable_variables) self.optimizer.apply_gradients( zip(grads, self.policy.trainable_variables)) # update average entropy and reward entropy = self.entropy(np.array(action_probs_history)) average_entropy, self.entropies = self.update_average( self.entropies, entropy) average_reward, self.episode_rewards = self.update_average( self.episode_rewards, episode_reward) # plot averages if self.plot: plot.update(value=average_reward, idx=0) plot.update(value=average_entropy, idx=1) # update learning rate if (average_reward > self.best_average_reward): self.best_average_reward = average_reward lr = self.optimizer._decayed_lr('float32').numpy() if (average_reward > self.lr_update_threshold): self.lr_update_threshold = average_reward * 1.5 lr = lr * 0.99 K.set_value(self.optimizer.learning_rate, lr) print( f"new max average={average_reward}/{self.env.spec.reward_threshold}; learning rate={lr:.7f}" ) # render test if self.render_period > 0 and (episode % self.render_period) == 0: r = self.render() print(f"test episode={episode} reward={r}") # print episode summary t_end = time.time() if episode % 10 == 0: print("episode: {}/{} fps={:.2f} reward last/avg/max_avg: {:.2f}/{:.2f}/{:.2f} loss actor={:.5f} critic={:.5f} entropy={:.5f} sequence len={:d}"\ .format(episode, self.num_episodes, len(rewards_history) / (t_end - t_start),\ episode_reward, average_reward, self.best_average_reward, actor_loss, critic_loss, average_entropy, len(rewards_history))) # exit if solved if self.best_average_reward > self.env.spec.reward_threshold: print( f"completed in {episode} episodes; average score={self.best_average_reward} threshold={self.env.spec.reward_threshold}" ) break
BSMO_NET, BSMO_CHID, R, Trash = Optimizer_Array[2](INIT_NET, Alive_Node, R=R, First=True, Update=True) SSMOMH_NET, SSMOMH_CHID, R, Trash = Optimizer_Array[3](INIT_NET, Alive_Node, R=R, First=True, Update=True) CHID_Arr = [INIT_CHID, LEACHC_CHID, PSOC_CHID, BSMO_CHID, SSMOMH_CHID] network_array = [INIT_NET, LEACHC_NET, PSOC_NET, BSMO_NET, SSMOMH_NET] plt.figure(1) Plot.Topology(network_array, CHID_Arr, [2, 3]) ## Plot Energy Consume Data plt.figure(2) FHL_ALL = [] PACKET_ALL = [] Time = [] for i in range(0, len(Optimizer_Array)): FHL = [] FHL, PACKET, _TIME = Plot.EnergyConsume(INIT_NET, Optimizer_Array[i], Alive_Node, Label=cf.Optimizer[i + 1], Alive=1, Total=0, Average=1,
from utils import Plot import noise import math SQRT_2 = 1.41421356237 p = Plot() def rotate(x, y, angle): x -= 50 y -= 50 point = ( x * math.cos(angle) - y * math.sin(angle), x * math.sin(angle) + y * math.cos(angle), ) return ( point[0] + 50, point[1] + 50, ) def in_canvas(point): return (point[0] >= 0 and point[0] <= 100 and point[1] >= 0 and point[1] <= 100) def draw_color(angle, threshold, noise_scale, noise_offset): num_rows = 100 num_cols = 100 grid_size = 100 * SQRT_2