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
