def approx_rbfn_iterative_TestNB(self): idx = [] res = np.zeros((10)) for x in range(200): for i in range(10): max_iter = 100 model = RBFN(15) start = time.process_time() # Generate a batch of data and store it self.reset_batch() g = SampleGenerator() for j in range(max_iter): # Draw a random sample on the interval [0,1] x = np.random.random() y = g.generate_non_linear_samples(x) self.x_data.append(x) self.y_data.append(y) # Comment the ones you don't want to use model.train_gd(x, y, alpha=i * 0.02 + 1) #model.train_rls(x, y) # model.train_rls_sherman_morrison(x, y) res[i] += model.residuals(self.x_data, self.y_data) for i in range(10): idx.append(i * 0.02 + 1) res[i] /= 200 plt.plot(idx, res, color="red") plt.show() print("RBFN Incr time:", time.process_time() - start)
def approx_rbfn_iterative_Test_Iter(self): model = RBFN(50) start = time.process_time() # Generate a batch of data and store it self.reset_batch() g = SampleGenerator() idx = [] res = [] for i in range(20, 1000): # Draw a random sample on the interval [0,1] x = np.random.random() y = g.generate_non_linear_samples(x) self.x_data.append(x) self.y_data.append(y) # Comment the ones you don't want to use # model.train_gd(x, y, alpha=0.5) model.train_rls(x, y) # model.train_rls_sherman_morrison(x, y) residuals = model.residuals(self.x_data, self.y_data) idx.append(i) print(residuals) res.append(residuals / i) plt.plot(idx, res) plt.show()
def set_mode(self, mode): assert mode == '4D' or mode == '6D' self.mode = mode if self.mode == '4D': self.rbfn = RBFN(J=6, input_dim=3) self.rbfn.load(path='../weights/4D_RBFN_params.txt') elif self.mode == '6D': self.rbfn = RBFN(J=8, input_dim=5) self.rbfn.load(path='../weights/6D_RBFN_params.txt')
def approx_rbfn_batch(self): model = RBFN(nb_features=10) self.make_nonlinear_batch_data() start = time.process_time() model.train_ls(self.x_data, self.y_data) print("RBFN LS time:", time.process_time() - start) model.plot(self.x_data, self.y_data) start = time.process_time() model.train_ls2(self.x_data, self.y_data) print("RBFN LS2 time:", time.process_time() - start) model.plot(self.x_data, self.y_data)
def approx_rbfn_batch_test(self, nb_features): model = RBFN(nb_features) self.make_nonlinear_batch_data() # start = time.process_time() # model.train_ls(self.x_data, self.y_data) # print("RBFN LS time:", time.process_time() - start) # model.plot(self.x_data, self.y_data) start = time.process_time() model.train_ls2(self.x_data, self.y_data) print("RBFN LS2 time:", time.process_time() - start) # model.plot(self.x_data, self.y_data) return nb_features, model.residuals(self.x_data, self.y_data)
def __init__(self, iteration_times=10000, populations_size=50, mutation_prob=0.3, crossover_prob=0.8, J=8, input_dim=5, dataset_path='../data/train6dAll.txt'): self.iteration_times = iteration_times self.populations_size = populations_size self.mutation_prob = mutation_prob self.crossover_prob = crossover_prob self.J = J self.input_dim = input_dim self.dataset_path = dataset_path self.cross_mask = None self.mutation_mask = None self.cross_select_prob = 0.5 self.mutation_select_prob = 0.5 self.populations = [] self.fitness = [] self.best_size = int(self.populations_size / 2) self.dataset = Dataset(self.dataset_path) self.model = RBFN(J=self.J, input_dim=self.input_dim) self.best_f = 10000000 self.start_time = time() for _ in range(populations_size): r = RBFN(J=self.J, input_dim=self.input_dim) f = r.eval(self.dataset.get()) theta, neurals = r.get_params() self.populations.append(RBFN.params2flatten(theta, neurals)) self.fitness.append(f)
def approx_rbfn_iterative(self): residuals = 0 t = 0 for i in range(100): max_iter = 500 model = RBFN(nb_features=15) start = time.process_time() # Generate a batch of data and store it self.reset_batch() g = SampleGenerator() for i in range(max_iter): # Draw a random sample on the interval [0,1] x = np.random.random() y = g.generate_non_linear_samples(x) self.x_data.append(x) self.y_data.append(y) # Comment the ones you don't want to use # model.train_gd(x, y, alpha=0.5) # model.train_rls(x, y) model.train_rls_sherman_morrison(x, y) # if(i == 500): # model.plot(self.x_data, self.y_data) print("RBFN Incr time:", time.process_time() - start) t += time.process_time() - start residuals += model.residuals(self.x_data, self.y_data) print(residuals / 100, t / 100) model.plot(self.x_data, self.y_data)
def __init__(self, master): tk.Frame.__init__(self, master) self.root = master self.grid() self.data = self.load_data() self.car, self.road = self.init_components() self.state = State.PLAYING self.dataset_path = '../data/train6dAll.txt' self.rbfn_weight_path = '../data/6D_RBFN_params.txt' self.mode = '4D' self.rbfn = RBFN(J=6, input_dim=3) self.rbfn.load(path='../weights/4D_RBFN_params.txt') self.set_mode('6D') self.ga = GA() self.recorder = Recorder() self.recorder.add(self.car) self.create_widgets() self.clean_fig() self.draw_road(self.road.finish_area, self.road.road_edges) self.draw_car(self.car.loc(), self.car.car_degree, self.car.radius)
def eval_fitness(self): self.fitness = [] r = RBFN(J=self.J, input_dim=self.input_dim) for i in range(self.populations_size): theta, neurals = RBFN.flatten2params(self.populations[i], self.input_dim) # print(neurals) r.set_params(theta, neurals) f = r.eval(self.dataset.get()) self.fitness.append(f)
def select(self): next_gen_populations = [] # keep the best one * 2 best = deepcopy(self.populations[self.fitness.index(min( self.fitness))]) for _ in range(self.best_size): next_gen_populations.append(deepcopy(best)) theta, neurals = RBFN.flatten2params(best, self.input_dim) self.model.set_params(theta, neurals) if min(self.fitness) < self.best_f: self.model.save() self.best_f = min(self.fitness) for _ in range(self.populations_size - self.best_size): # next_gen_populations.append( # deepcopy(self.populations[self.roulette()])) picked = random.sample(self.populations, 2) for p in picked: next_gen_populations.append(deepcopy(p)) random.shuffle(next_gen_populations) self.populations = next_gen_populations
class GUI(tk.Frame): def __init__(self, master): tk.Frame.__init__(self, master) self.root = master self.grid() self.data = self.load_data() self.car, self.road = self.init_components() self.state = State.PLAYING self.dataset_path = '../data/train6dAll.txt' self.rbfn_weight_path = '../data/6D_RBFN_params.txt' self.mode = '4D' self.rbfn = RBFN(J=6, input_dim=3) self.rbfn.load(path='../weights/4D_RBFN_params.txt') self.set_mode('6D') self.ga = GA() self.recorder = Recorder() self.recorder.add(self.car) self.create_widgets() self.clean_fig() self.draw_road(self.road.finish_area, self.road.road_edges) self.draw_car(self.car.loc(), self.car.car_degree, self.car.radius) def set_mode(self, mode): assert mode == '4D' or mode == '6D' self.mode = mode if self.mode == '4D': self.rbfn = RBFN(J=6, input_dim=3) self.rbfn.load(path='../weights/4D_RBFN_params.txt') elif self.mode == '6D': self.rbfn = RBFN(J=8, input_dim=5) self.rbfn.load(path='../weights/6D_RBFN_params.txt') def change_mode(self): if self.mode == '4D': self.set_mode('6D') self.im['text'] = '6D' else: self.set_mode('4D') self.im['text'] = '4D' def load_data(self): case_file_path = '../cases/case01.txt' d = Data(case_file_path) return d.get() def init_components(self): c = Car(self.data['start_point'], self.data['start_degree']) c.update_sensor(self.data['road_edges']) r = Road(self.data['finish_area'], self.data['road_edges']) return c, r def create_widgets(self): # 標題 self.winfo_toplevel().title("Yochien CI HW2") # 自走車位置、方向、感測器距離 _, self.loc = add_text(self, 0, "Car Location", self.car.loc()) _, self.fl = add_text(self, 1, "Car Sensor Front Left", self.car.sensor_dist['fl']) _, self.f = add_text(self, 2, "Car Sensor Front", self.car.sensor_dist['f']) _, self.fr = add_text(self, 3, "Car Sensor Front Right", self.car.sensor_dist['fr']) _, self.cd = add_text(self, 4, "Car Degree", self.car.car_degree) _, self.swd = add_text(self, 5, "Car Steering Wheel Degree", self.car.steering_wheel_degree) # 更新車子 _, self.next = add_button(self, 6, "Start Playing", "Run", self.run) # 目前狀態 _, self.st = add_text(self, 7, "Status", self.state) # 迭代次數 _, self.it = add_spinbox(self, 8, "Iterate Times", 10, 10000) # 族群大小 _, self.ps = add_spinbox(self, 9, "Population Size", 10, 10000) # 突變機率 _, self.mp = add_spinbox(self, 10, "Mutation Prob(%)", 1, 100) # 交配機率 _, self.cp = add_spinbox(self, 11, "Cross Prob(%)", 1, 100) # 選取訓練資料集 _, self.td = add_text(self, 12, "Training Dataset", self.dataset_path) _, self.next = add_button(self, 13, "Select Dataset", "Select", self.select_dataset_file) # 選取RBFN weight _, self.rbfn_wf = add_text(self, 14, "RBFN weight file", self.rbfn_weight_path) _, self.srbfn_wf = add_button(self, 15, "Select RBFN weight", "Select", self.select_rbfn_weight_file) # 選取Mode _, self.im = add_text(self, 16, "Input Mode (4D/6D)", self.mode) _, self.cm = add_button(self, 17, "Change Mode", "Change", self.change_mode) # Train RBFN _, self.tb = add_button(self, 18, "Train RBFN", "Train", self.train_ga) # 地圖與道路 self.road_fig = Figure(figsize=(5, 5), dpi=120) self.road_canvas = FigureCanvasTkAgg(self.road_fig, self) self.road_canvas.draw() self.road_canvas.get_tk_widget().grid(row=19, column=0, columnspan=3) def train_ga(self): if self.mode == '4D': J = 6 input_dim = 3 else: J = 8 input_dim = 5 iteration_times = int(self.it.get()) populations_size = int(self.ps.get()) mutation_prob = int(self.mp.get()) / 100 crossover_prob = int(self.cp.get()) / 100 print(iteration_times, populations_size, mutation_prob, crossover_prob) self.GA = GA(iteration_times=iteration_times, populations_size=populations_size, mutation_prob=mutation_prob, crossover_prob=crossover_prob, J=J, input_dim=input_dim, dataset_path=self.dataset_path) self.GA.train() def select_rbfn_weight_file(self): try: filename = askopenfilename() self.rbfn_wf["text"] = filename self.rbfn_weight_path = filename self.rbfn.load(path=filename) except Exception as e: print(e) self.rbfn_wf["text"] = "" def select_dataset_file(self): try: filename = askopenfilename() self.td["text"] = filename self.dataset_path = filename self.ga = GA(dataset_path=filename) except Exception as e: print(e) self.td["text"] = "" def turn_steering_wheel(self, degree): self.car.turn_steering_wheel(degree) def run(self): while self.state == State.PLAYING: self.update() sleep(0.02) def update(self): self.update_state() self.update_car() self.recorder.add(self.car) def update_state(self): if self.road.is_crash(self.car): self.state = State.CRASH elif self.road.is_finish(self.car): self.state = State.FINISH self.recorder.to_file() self.st["text"] = self.state def update_car(self): fl, f, fr = self.car.update_sensor(self.data['road_edges']) if self.mode == '4D': self.turn_steering_wheel(self.rbfn.output([f, fr, fl])) elif self.mode == '6D': x, y = self.car.loc() self.turn_steering_wheel(self.rbfn.output([x, y, f, fr, fl])) self.car.next() self.loc["text"] = self.car.loc() self.cd["text"] = self.car.car_degree self.swd["text"] = self.car.steering_wheel_degree self.clean_fig() self.draw_road(self.road.finish_area, self.road.road_edges) self.draw_car(self.car.loc(), self.car.car_degree, self.car.radius) self.draw_route() self.road_canvas.draw() def clean_fig(self): # 清空並初始化影像 self.road_fig.clf() self.road_fig.ax = self.road_fig.add_subplot(111) self.road_fig.ax.set_aspect(1) self.road_fig.ax.set_xlim([-20, 60]) self.road_fig.ax.set_ylim([-10, 60]) def draw_road(self, finish_area, road_edges): # 車道邊界 for i in range(len(road_edges) - 1): self.road_fig.ax.text( road_edges[i][0], road_edges[i][1], '({},{})'.format(road_edges[i][0], road_edges[i][1])) self.road_fig.ax.plot([road_edges[i][0], road_edges[i + 1][0]], [road_edges[i][1], road_edges[i + 1][1]], 'k') # 終點區域 a, b = finish_area[0] c, d = finish_area[1] self.road_fig.ax.plot([a, c], [b, b], 'r') self.road_fig.ax.plot([c, c], [b, d], 'r') self.road_fig.ax.plot([c, a], [d, d], 'r') self.road_fig.ax.plot([a, a], [d, b], 'r') def draw_car(self, loc, car_degree, radius): # 車子範圍 self.road_fig.ax.plot(loc[0], loc[1], '.b') circle = plt.Circle(loc, radius, color='b', fill=False) self.road_fig.ax.add_artist(circle) # 感測器 self.fl["text"], self.f["text"], self.fr[ "text"] = self.car.update_sensor(self.data['road_edges']) for s in self.car.sensor_point: self.road_fig.ax.plot([loc[0], self.car.sensor_point[s][0]], [loc[1], self.car.sensor_point[s][1]], 'r') self.road_fig.ax.plot(self.car.sensor_point[s][0], self.car.sensor_point[s][1], '.b') def draw_route(self): records = self.recorder.get() for r in records: self.road_fig.ax.plot(int(float(r[0]) + 0.0001), int(float(r[1]) + 0.0001), '.y')
plot_posterior_predictive(x_grid, f_pred, ax=ax[2,i],alpha=alpha,\ plot_all=True,plot_uncertainty=False,diff_colors=diff_colors) f_pred = bnn.sample_functions_prior(x_tensor, n_samples_all) f_pred = f_pred[:, :, np.newaxis].detach().numpy() var_val = compute_var_lines(ax[2, i], x_grid, f_pred) print('model=%s, lambda=low, var=%.3f' % ('bnn', var_val)) ###### Prior samples from Doucet x = np.random.randn(200, 1) y = np.random.randn(200, 1) print(x.shape) print(y.shape) k = 20 i = 2 rbfn = RBFN(x, y, k, eps1=5.0, eps2=0.5, l=1.0, nu_0=1.5, gamma_0=1) f_pred = rbfn.sample_functions_prior(x_grid, n_samples, sample_K=True) f_pred = f_pred[:, :, np.newaxis] plot_posterior_predictive(x_grid, f_pred, ax=ax[0,i],alpha=alpha,\ plot_all=True,plot_uncertainty=False,diff_colors=diff_colors) f_pred = rbfn.sample_functions_prior(x_grid, n_samples_all, sample_K=True) f_pred = f_pred[:, :, np.newaxis] var_val = compute_var_lines(ax[0, i], x_grid, f_pred) print('model=%s, lambda=low, var=%.3f' % ('doucet', var_val)) ax[0, i].set_title('B-RBFN') rbfn = RBFN(x, y, k, eps1=30.0, eps2=0.5, l=15.0, nu_0=1.5, gamma_0=1) f_pred = rbfn.sample_functions_prior(x_grid, n_samples, sample_K=True)[:, :, np.newaxis] plot_posterior_predictive(x_grid, f_pred, ax=ax[1,i],alpha=alpha,\ plot_all=True,plot_uncertainty=False,diff_colors=diff_colors)
import util from rbfn import RBFN if __name__ == '__main__': # dataset_file = raw_input('Training dataset location: ') dataset_file = 'dataset.csv' training_dataset, test_dataset = util.split_dataset(dataset_file) training_inputs, training_outputs = util.separate_dataset_io( training_dataset, is_training=True) rbfn = RBFN(n_centroids=8) rbfn.train(training_inputs, training_outputs) test_inputs, test_outputs = util.separate_dataset_io( test_dataset, is_training=True) results = rbfn.predict(test_inputs) print util.evaluate(test_outputs, results)
class GA(): def __init__(self, iteration_times=10000, populations_size=50, mutation_prob=0.3, crossover_prob=0.8, J=8, input_dim=5, dataset_path='../data/train6dAll.txt'): self.iteration_times = iteration_times self.populations_size = populations_size self.mutation_prob = mutation_prob self.crossover_prob = crossover_prob self.J = J self.input_dim = input_dim self.dataset_path = dataset_path self.cross_mask = None self.mutation_mask = None self.cross_select_prob = 0.5 self.mutation_select_prob = 0.5 self.populations = [] self.fitness = [] self.best_size = int(self.populations_size / 2) self.dataset = Dataset(self.dataset_path) self.model = RBFN(J=self.J, input_dim=self.input_dim) self.best_f = 10000000 self.start_time = time() for _ in range(populations_size): r = RBFN(J=self.J, input_dim=self.input_dim) f = r.eval(self.dataset.get()) theta, neurals = r.get_params() self.populations.append(RBFN.params2flatten(theta, neurals)) self.fitness.append(f) def roulette(self): fitness = g.fitness min_fit = min(fitness) if min_fit < 0: fitness = [fit - min_fit + 1 for fit in fitness] posibility = [fit / sum(fitness) for fit in fitness] total_posibility = [ sum(posibility[:i + 1]) for i in range(len(posibility)) ] rand = random.random() for i, v in enumerate(total_posibility): if rand < v: return i def eval_fitness(self): self.fitness = [] r = RBFN(J=self.J, input_dim=self.input_dim) for i in range(self.populations_size): theta, neurals = RBFN.flatten2params(self.populations[i], self.input_dim) # print(neurals) r.set_params(theta, neurals) f = r.eval(self.dataset.get()) self.fitness.append(f) def select(self): next_gen_populations = [] # keep the best one * 2 best = deepcopy(self.populations[self.fitness.index(min( self.fitness))]) for _ in range(self.best_size): next_gen_populations.append(deepcopy(best)) theta, neurals = RBFN.flatten2params(best, self.input_dim) self.model.set_params(theta, neurals) if min(self.fitness) < self.best_f: self.model.save() self.best_f = min(self.fitness) for _ in range(self.populations_size - self.best_size): # next_gen_populations.append( # deepcopy(self.populations[self.roulette()])) picked = random.sample(self.populations, 2) for p in picked: next_gen_populations.append(deepcopy(p)) random.shuffle(next_gen_populations) self.populations = next_gen_populations def gen_cross_mask(self, force=False): if self.cross_mask is None or force: cross_mask = [] for _ in range(len(self.populations[0])): rand = random.random() if rand < self.cross_select_prob: cross_mask.append(True) else: cross_mask.append(False) self.cross_mask = cross_mask #print("generate cross mask") # print(self.cross_mask) def crossover(self): self.gen_cross_mask() for i in range(int(self.populations_size / 2)): self.gen_cross_mask(True) rand = random.random() if rand < self.crossover_prob: self.cross(self.populations[i * 2], self.populations[i * 2 + 1]) # for j in range(len(self.populations[0])): # if self.cross_mask[j]: # temp = self.populations[i*2][j] # self.populations[i*2][j] = self.populations[i*2+1][j] # self.populations[i*2+1][j] = temp def cross(self, a, b): ratio = (random.random() - 0.5) * 2 * self.crossover_prob aa = deepcopy(a) bb = deepcopy(b) for i in range(len(a)): aa[i] = a[i] + ratio * (a[i] - b[i]) bb[i] = b[i] - ratio * (a[i] - b[i]) return aa, bb def gen_mutation_mask(self, force=True): if self.mutation_mask is None or force: mutation_mask = [] for _ in range(len(self.populations[0])): rand = random.random() if rand < self.mutation_select_prob: mutation_mask.append(True) else: mutation_mask.append(False) self.mutation_mask = mutation_mask #print("generate mutation mask") # print(self.mutation_mask) def mutation(self): # self.gen_mutation_mask() for i in range(int(self.populations_size)): rand = random.random() # if rand < self.mutation_prob: # print("YYYYYYYYYYYY") # self.gen_mutation_mask(True) # print(self.mutation_mask) # print(self.populations[i]) for j in range(len(self.populations[0])): rand = random.random() if rand < self.mutation_prob: self.populations[i][j] = self.mutate( self.populations[i][j]) # if self.mutation_mask[j]: # if (j-1)%(self.input_dim+2) == 0: # self.populations[i][j] = random.uniform(0, 1) # elif (j-1)%(self.input_dim+2) == self.input_dim+1: # self.populations[i][j] = random.uniform(-1, 1) # else: # self.populations[i][j] = random.uniform(0, 40) # print(self.populations[i]) def mutate(self, v): ratio = (random.random() - 0.5) * 2 * 0.5 result = v + v * ratio return result def train(self): for epoch in range(self.iteration_times): self.eval_fitness() print( "time(sec):{} epoch-{} Best fitness = {}, averag fitness = {}". format(int(time() - self.start_time), epoch, self.best_f, sum(self.fitness) / self.populations_size)) #print(list(map(lambda x: int(x), self.fitness))) self.select() self.crossover() self.mutation()