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()