def get_inital_estimate(data_point_x): # getting fuzzified value fuzz_val = [] for mem in input_fuzz_set: fuzz.fuzzify(data_point_x, mem) fuzz_val.append(mem.fuzz_val) # premise values premise_val = np.zeros((len(fuzz_val),)) for i in range(len(fuzz_val)): premise_val[i] = fuzz_val[i] # implied fuzzy set membership equals the premise values as we are usign singleton sets # for output # fuzzy basis functions fuzz_basis = premise_val/np.sum(premise_val) # new phi vector phi = fuzz_basis phi_t = np.transpose(phi) # getting RLS update variables lam = 1.0/np.dot(phi_t, phi) theta = np.dot(lam, phi_t*data_point_y(data_point_x)) return theta, lam
def main(): data_point_x = random.random()*6.0 #first_theta, first_lam = get_inital_estimate(data_point_x) first_theta = np.zeros((4,)) first_lam = 1000000*np.identity(4) for i in range(n_points): data_point_x = random.random()*6.0 if i == 0: prev_theta, prev_lam = get_estimate(data_point_x, first_lam, first_theta) else: prev_theta, prev_lam = get_estimate(data_point_x, prev_lam, prev_theta) final_theta = prev_theta print(final_theta) # comparison new_func = np.zeros_like(x) b = final_theta fuzz_basis_2 = np.zeros((len(x), len(input_fuzz_set))) temp = np.zeros((4,)) for i in range(len(x)): for j in range(len(input_fuzz_set)): fuzz.fuzzify(x[i], input_fuzz_set[j]) temp[j] = input_fuzz_set[j].fuzz_val fuzz_basis_2[i] = temp/np.sum(temp) g_cap = np.zeros_like(x) for i in range(len(x)): g_cap[i] = b[0]*fuzz_basis_2[i,0] + b[1]*fuzz_basis_2[i,1] + b[2]*fuzz_basis_2[i,2] + b[3]*fuzz_basis_2[i,3] g = x - cos(1.5*x) + sin(0.4*x) plt.plot(x, g, x, g_cap) plt.show()
def model(t, X, params): x1, x2 = X e_memship, e_dot_memship, i_memship = params r = (math.pi / 2) + math.sin(math.pi * t) rdot = math.pi * math.cos(math.pi * t) e = x1 - r edot = x2 - rdot for i in range(len(e_memship)): fuzz.fuzzify(e, e_memship[i]) fuzz.fuzzify(edot, e_dot_memship[i]) e_fuzz = [] e_dot_fuzz = [] for i in range(len(e_memship)): e_fuzz.append(e_memship[i].fuzz_val) e_dot_fuzz.append(e_dot_memship[i].fuzz_val) i_fuzz = rule_set(e_fuzz, e_dot_fuzz) i = fuzz.defuzzify(i_fuzz, i_memship, 'CAD') x1dot = x2 x2dot = -64 * math.sin(x1) - 5 * x2 + 4 * i return [x1dot, x2dot]
def get_estimate(data_point_x, prev_lam, prev_theta): # getting fuzzified value fuzz_val = [] for mem in input_fuzz_set: fuzz.fuzzify(data_point_x, mem) fuzz_val.append(mem.fuzz_val) # premise values premise_val = np.zeros((len(fuzz_val),)) for i in range(len(fuzz_val)): premise_val[i] = fuzz_val[i] # implied fuzzy set membership equals the premise values as we are usign singleton sets # for output # fuzzy basis functions fuzz_basis = premise_val/np.sum(premise_val) # new phi vector phi = fuzz_basis phi_t = np.transpose(phi) # RLS update new_y = data_point_y(data_point_x) gamma = (np.dot(prev_lam, phi))/(1 + np.dot(phi_t, np.dot(prev_lam, phi))) R_x_R_identity = np.identity(4) new_lam = np.dot((R_x_R_identity - np.dot(gamma, phi_t)), prev_lam) new_theta = prev_theta + np.dot(gamma, (new_y - np.dot(phi_t, prev_theta))) return new_theta, new_lam
def get_fuzzy_basis(x, memship): fuzz_basis = np.zeros((len(memship, ))) for i in range(len(memship)): fuzz.fuzzify(x, memship[i]) fuzz_basis[i] = memship[i].fuzz_val return fuzz_basis
def model(t, X, params): x1, x2 = X x1_fuzz_mem, x2_fuzz_mem = params x1_fuzz = [] x2_fuzz = [] u = 3 * math.sin(math.pi * t) for i in range(len(x1_fuzz_mem)): fuzz.fuzzify(x1, x1_fuzz_mem[i]) fuzz.fuzzify(x2, x2_fuzz_mem[i]) for i in range(len(x1_fuzz_mem)): x1_fuzz.append(x1_fuzz_mem[i].fuzz_val) x2_fuzz.append(x2_fuzz_mem[i].fuzz_val) fuzz_basis = get_fuzzy_basis(x1_fuzz, x2_fuzz) A = np.zeros_like(A1) B = np.zeros_like(B1) i = 0 for x in fuzz_basis: A += A_i[i] * x B += B_i[i] * x i += 1 x1dot = A[0, 0] * x1 + A[0, 1] * x2 + B[0, 0] * u x2dot = A[1, 0] * x1 + A[1, 1] * x2 + B[1, 0] * u return [x1dot, x2dot]
def get_fuzz_basis(e, e_mem, de, de_mem): temp = np.zeros((n_rules, 1)) # get fuzzy membership values fo reach membership func for i in range(n_sets): fuzz.fuzzify(e, e_mem[i]) fuzz.fuzzify(de, de_mem[i]) # get rule premise values k = 0 for i in range(n_sets): for j in range(n_sets): temp[k, 0] = e_mem[i].fuzz_val * de_mem[j].fuzz_val k += 1 # get basis funcs temp = temp / (np.sum(temp)) return temp
def compare(b, c, sig, memship): fuzz_basis = np.zeros((len(x), n_rules)) memship = update_fuzzy_sets(memship, c, sig) temp = np.zeros((n_rules, )) for i in range(len(x)): for j in range(n_rules): fuzz.fuzzify(x[i], memship[j]) temp[j] = memship[j].fuzz_val fuzz_basis[i] = temp / np.sum(temp) g_cap = np.zeros_like(x) for i in range(len(x)): g_cap[i] = b[0] * fuzz_basis[i, 0] + b[1] * fuzz_basis[ i, 1] + b[2] * fuzz_basis[i, 2] + b[3] * fuzz_basis[ i, 3] + b[4] * fuzz_basis[i, 4] plt.plot(x, g, x, g_cap) plt.show()
def model(t, X, params): x1, x2 = X e = -x1 edot = -x2 e_mem, edot_mem, v_mem = params e_fuzz_mem = [] edot_fuzz_mem = [] for z in e_mem: fuzz.fuzzify(e, z) e_fuzz_mem.append(z.fuzz_val) for z in edot_mem: fuzz.fuzzify(edot, z) edot_fuzz_mem.append(z.fuzz_val) rule_out = ball_beam_rule_set(e_fuzz_mem, edot_fuzz_mem) v = fuzz.defuzzify(rule_out, v_mem, 'CAD') u.append(v) x1dot = x2 x2dot = 9.81 * math.sin(0.02 * v) return [x1dot, x2dot]
names = 'none' memship_1 = [] memship_2 = [] for x in centres: params.append([x, spread, option]) for x in params: memship_1.append(fuzz.membership('gauss', x, x1, names)) memship_2.append(fuzz.membership('gauss', x, x2, names)) # fuzzified value set fuzz_val_set_1 = np.zeros((len(x1_cap), len(memship_1))) fuzz_val_set_2 = np.zeros((len(x2_cap), len(memship_2))) temp = np.zeros((len(memship_1), )) for i in range(len(x1_cap)): for j in range(len(memship_1)): fuzz.fuzzify(x1_cap[i], memship_1[j]) temp[j] = memship_1[j].fuzz_val fuzz_val_set_1[i] = temp for i in range(len(x2_cap)): for j in range(len(memship_2)): fuzz.fuzzify(x2_cap[i], memship_2[j]) temp[j] = memship_2[j].fuzz_val fuzz_val_set_2[i] = temp # get rule premise values fuzz_rule_premise = np.zeros((len(x1_cap), len(memship_1) * len(memship_2))) temp = np.zeros((len(memship_1) * len(memship_2), )) l = 0 for i in range(len(x1_cap)): for j in range(len(memship_1)): for k in range(len(memship_2)):
p1 = [0, 1.184, 'none'] p2 = [2, 1.184, 'none'] p3 = [4, 1.184, 'none'] p4 = [6, 1.184, 'none'] params = [p1, p2, p3, p4] memship = [] names = 'none' for z in params: memship.append(fuzz.membership('gauss', z, x, 'none')) # premise memship and fuzzy basis fuzz_val_set = np.zeros((len(x_estimate), len(memship))) temp = np.zeros((len(memship),)) for i in range(len(x_estimate)): for j in range(len(memship)): fuzz.fuzzify(x_estimate[i], memship[j]) temp[j] = memship[j].fuzz_val fuzz_val_set[i] = temp # LSE phi = np.zeros_like(fuzz_val_set) for i in range(len(x_estimate)): a1 = np.sum(fuzz_val_set[i]) b1 = (fuzz_val_set[i])/a1 phi[i] = b1 phi_t = np.transpose(phi) phi_t_phi = np.dot(phi_t, phi) phi_t_phi_inv = inv(phi_t_phi) Y = np.array(g_estimate).reshape((len(g_estimate),1)) theta_cap = np.dot(phi_t_phi_inv, (np.dot(phi_t, Y)))
def get_rule_premise(x, memship): rule_premise = np.zeros((n_rules, 1)) for i in range(len(memship)): fuzz.fuzzify(x, memship[i]) rule_premise[i, 0] = memship[i].fuzz_val return rule_premise