lock.acquire()

if len(xs) > 0 and len(ys) > 0:

ax.plot(xs, ys, 'b-')

last_x = xs[len(xs) - 1]

last_y = ys[len(ys) - 1]

xs.clear()

ys.clear()

xs.append(last_x)

ys.append(last_y)

if x.shape[0] == 1:

return np.asscalar(np.sqrt(np.dot(x, x.T)))

elif x.shape[1] == 1:

return np.asscalar(np.sqrt(np.dot(x.T, x)))

else:

# e = amax(abs(x))

e = np.average(abs(x))

# e = mag(x)

data = np.loadtxt(path,

comments=';;', delimiter=',')

data = np.array(data)

_i = NEURONS_BY_LAYER[0]

_o = NEURONS_BY_LAYER[-1]

x = data[:, :_i]

y = data[:, -_o:]

s = data.shape[0]

# Grafo de distancia (pontos x -versus- medias m)

d = distance_graph(x, c.T)

m = np.reshape(np.amin(d, axis=1), (-1, 1))

# Grafo de grupos

u, d = pertains_graph(x, c.T)

# Marca zeros com -1 para evitar confusão na seleção de pontos com distância 0

u = np.where(u == 0, -1, u)

# Números positivos indicam distância do ponto até o centro do grupo

g = u * d

# Indice de linha do maior valor

# (é por causa desta linha que marcamos com números

# negativos distância de grupos não pertencentes, pois

# grupos de um único elemento tem distância zero, o que

# faria pontos de outros grupo serem selecionados caso

# tambem fossem marcados com 0)

m = np.argmax(g, axis=0)

# Indices de coluna dos grupos

n = np.arange(u.shape[1])

# Marca com 1 os pontos mais distante de cada grupo

f = np.zeros(np.shape(u))

f[m, n] = 1

# Matrix de pertinencia original

u = (u > 0) * 1

# Um grupo sem elementos não tera nenhum ponto selecionado por causa de f * u

dim = x.shape[1]

# Maximo de cada eixo (coluna)

axis_max = np.amax(x, axis=0)

# Minimo de cada eixo (coluna)

axis_min = np.amin(x, axis=0)

# Medias inicializadas aleatoriamente (dentro do maximo e minimo em cada eixo)

m = np.random.random((k, dim)) * (axis_max - axis_min) + axis_min

lm = None

# Continua execucao ate nao haver mais alteração nas medias

while not np.array_equal(m, lm):

lm = m

# Matriz de pertinencia (pontos x -versus- medias m)

u, d = pertains_graph(x, m)

# Quantidade de pontos em cada grupo

n = np.sum(u, axis=0)

# Somatório das coordenadas dos pontos

s = np.dot(x.T, u)

# Calculo das centroides

c = (s / n).T

# Atualiza novas médias com centróides dos grupos encontrados

m = np.where(np.isnan(c), m, c)

# existem duas formas de fazer o calculo:

# Primeira: usando a média dos N vetores mais proximos =. sigma = 1/N somatorio ||centro mais proximo - vetores mais proximos||, N = vetores mais proximos

# Segunda: pelo ponto mais distantes pertencentes ao cluster do centro Cj

# A segunda e mais facil a implementacao

#

# 1 - Recebe sigma e os centros

# 2 - dentro de um loop, calcula qual é o maior em ||centro - entradai || e atribui o maior para sigma

# repare que quem se altera é somente a entrada

# 3 - retorna sigma

# Matriz indica qual ponto x é o mais distante de cada grupo

f, _, _ = farthest_graph(x, c)

# Marcando com nan grupos vazios

n = np.sum(f, axis=0)

f = f / n

# Seleção do vetor mais distante

v = np.dot(x.T, f)

# Distância entre vetor e centro do grupo

d = np.abs(c - v)

# Disperação padrão para distância zero ou grupo vazio

s = np.where(np.logical_and(d != 0, np.logical_not(np.isnan(d))), d, 0.1)

# Aumenta em 20% area de dispersão para melhorar englobamento

time.sleep(1)

x, y, n_patterns = load_dataset(PATH)

# Parametro de centro para RBF

c = k_means_clustering(x, NEURONS_BY_LAYER[1])

# c = np.array([[0, 0, 1, 1],

# [0, 1, 0, 1]])

# Vetor de dispersão

sigma = dispersion(x, c)

# sigma = np.array([[.1, .1, .1, .1],

# [.1, .1, .1, .1]])

# Aplicando a RBF

rbf_input = rbf(x, c, sigma)

x_p = np.hstack((np.ones((n_patterns, 1)), rbf_input))

y_p = y

NEURONS_BY_LAYER.pop(0)

w = []

# Vetor de pesos aleatorizado para cada camada

n_layers = len(NEURONS_BY_LAYER) - 1

for i in range(n_layers):

row = NEURONS_BY_LAYER[i] + 1

col = NEURONS_BY_LAYER[i + 1] + (1 if i < n_layers - 1 else 0)

rn = np.random.random((row, col))

wl = 2 * rn - 1

w.append(wl)

stopped_by_error_threshold = True

gi = 0

gama = GAMA

d2_w = []

for w_it in w:

d2_w.append(w_it * 0)

eta = ETA

for epoch in range(MAX_ITER):

for i in range(len(w) - 1):

w[i][:, 0] = 0

w[i][0][0] = 1

g = []

u = []

y_n = x_p

for i, w_it in enumerate(w):

u_n = np.dot(y_n, w_it)

g_n = transfer_f(u_n)

if i < len(w) - 1:

g_n[:, 0] = 1

u.append(u_n)

g.append(g_n)

y_n = g_n

dg = list(map(lambda u_it: derivative_tf(u_it), u))

e_n = y_p - g[-1]

e = [e_n]

for dg_it, w_it in zip(reversed(dg[1:]), reversed(w[1:])):

delta_n = e_n * dg_it

e_n = np.dot(delta_n, w_it.T)

e.insert(0, e_n)

if np.average(coalesce_error(e[-1])) < ERROR_THRESHOLD:

print("Final Epoch :")

print(epoch)

stopped_by_error_threshold = True

break

if epoch % 500 == 0:

print("Current Epoch:")

print(epoch)

print("Errors: ")

for i, e_it in enumerate(e):

print(" Layer: %d" % i)

print(" Avg: %.6f" % np.average(abs(e_it)))

print(" Mag: %.6f\n" % mag(e_it))

print("\nEtha")

print(eta)

print("\nWeights")

print(w)

print("\nError")

print(e)

lock.acquire()

xs.append(gi)

ys.append(coalesce_error(e[-1]))

lock.release()

gi += 1

e = list(map(lambda e_it, dg_it: e_it * dg_it, e, dg))

y_h = g[:-1]

y_h.insert(0, x_p)

d_w = list(map(lambda y_it, e_it: np.dot(y_it.T, e_it) / n_patterns, y_h, e))

for i in range(len(w)):

w[i] += eta * d_w[i] + (gama * d2_w[i] if MOMENTUM else 0)

d2_w = list(map(lambda d_w_it: eta * d_w_it, d_w))

if not stopped_by_error_threshold:

print("Iteration :")

print(MAX_ITER)

print("\nInput ")

print(x)

print("\nRBF Layer")

print(x_p)

print("\nCenter")

print(c)

print("\nDispersion")

print(sigma)

# testing output

g = []

y_n = x_p

for i, w_it in enumerate(w):

u_n = np.dot(y_n, w_it)

g_n = transfer_f(u_n)

if i < len(w) - 1:

g_n[:, 0] = 1

g.append(g_n)

y_n = g_n

print("\nOutput")

print(y_n)

print("\nTraining Data")

print(y_p)

print("\nError")

dg = list(map(lambda g_it: derivative_tf(g_it), g))

e_n = y_p - g[-1]

e = [e_n]

for dg_it, w_it in zip(reversed(dg[1:]), reversed(w[1:])):

delta_n = e_n * dg_it

e_n = np.dot(delta_n, w_it.T)

e.insert(0, e_n)

for i, e_it in enumerate(e):

print(" Layer: %d" % i)

print(" Avg: %.6f" % np.average(abs(e_it)))

print(" Mag: %.6f\n" % mag(e_it))

print("\nEtha")

print(eta)

print("\nSynaptic Weights")

for i in range(len(w) - 1):

w[i][:, 0] = 0

w[i][0][0] = 1

for i, w_it in enumerate(w):

print("Layer: %d" % i)

print(w_it)

while True: