def rodarAdaline(inputTreinamento, outputTreinamento):
log.print(">> Adaline")
adalines = [None]*5
for e in range(5):
log.print(f">> Treinamento {e + 1}")
adaline = Adaline(log, len(inputTreinamento[0]))
adaline.train(inputTreinamento, outputTreinamento, e + 1)
adalines[e] = adaline
testar(adalines, False)
def main(train=False):
digit_arrays = {
str(digit): [
load_image(f"{BASE_PATH}{digit}_{index}.png")
for index in range(HOW_MANY)
]
for digit in range(DIGITS)
}
flat_arrays = {
digit: list(map(image_to_bipolar_array, images))
for digit, images in digit_arrays.items()
}
learning_rate = 0.0005
network = Adaline(labels=list(digit_arrays.keys()),
learning_rate=learning_rate)
if train:
for label, sources in flat_arrays.items():
for source in sources:
network.add_sources(source, label)
max_cycles = 200
random_starting_weights = False
weight_adjustment_tolerance = None
square_error_tolerance = None
print(f"Max cycles: {max_cycles}\n--------------------------")
network.train(random_starting_weights=random_starting_weights,
max_cycles=max_cycles,
weight_adjustment_tolerance=weight_adjustment_tolerance,
square_error_tolerance=square_error_tolerance,
verbose=True)
network.save_neurons('neurons.pkl')
else:
network.load_neurons('neurons.pkl')
while True:
# test_image = draw.get_character()
test_image = load_image(input("image name:\n>>"))
if test_image is None:
break
flat = image_to_bipolar_array(test_image)
out = network.output(flat)
for key, value in out.items():
print(f"{key}: {value:.3f}")
def main():
sources_list = [[1, 1], [-1, 1], [1, -1], [-1, -1]]
targets = [1, 1, 1, -1]
square_errors = {}
learning_rates = [1e-4, 1e-3, 1e-2, 1e-1, 2e-1, 3e-1, 0.35, 0.4]
weight_adjustment_tolerance = None
square_error_tolerance = None
max_cycles = 50
network = Adaline(activation_function=activation_function)
for sources, target in zip(sources_list, targets):
network.add_sources(sources, target)
for learning_rate in learning_rates:
network.learning_rate = learning_rate
network.train(random_starting_weights=False,
max_cycles=max_cycles,
weight_adjustment_tolerance=weight_adjustment_tolerance,
square_error_tolerance=square_error_tolerance)
print(
f">>Learning rate: {learning_rate}\n\n"
f"Final weights:\n"
f"{[float(f'{weigth:.5f}') for weigth in network.neuron.weights]}\n"
f"Final bias:\n"
f"{network.neuron.bias:.5f}\n\n"
f"Cycles: {network.cycles}\n"
f"Final square error: {network.total_square_error_by_cycle[-1]:.5f}\n\n\n"
)
square_errors[learning_rate] = network.total_square_error_by_cycle
curves = []
for learning_rate, square_error in square_errors.items():
curves.append(
plt.plot(range(len(square_error)),
square_error,
'--',
linewidth=2,
label=str(learning_rate))[0])
plt.ylim([-0.1, 4])
plt.legend(handles=curves)
plt.show()
def adaline_implementation(targets_train, targets_test, patterns_train,
patterns_test, plot, d3):
a = Adaline()
max_epochs = int(input('Μέγιστος αριθμός εποχών: '))
learning_rate = float(input('Ρυθμός εκμάθησης: '))
min_mse = float(input('Ελάχιστο σφάλμα: '))
weights = a.train(max_epochs, patterns_train,
targets_train, learning_rate, min_mse, plot, d3)
# if plot == False:
guesses = a.test(weights, patterns_test, targets_test)
a.plot_accuracy(targets_test, guesses)
### azuis ----> Versicolor (1)
cm_bright = ListedColormap(['#FF0000', '#0000FF'])
plt.scatter([sum(r) for index, r in df.iterrows()],
x[:, 3],
c=y,
cmap=cm_bright)
plt.scatter(None, None, color='r', label='Versicolor')
plt.scatter(None, None, color='b', label='Setosa')
plt.legend()
plt.title('Visualizacao do Dataset (flores Iris)')
plt.savefig('train.png')
# Adaline com 4 entradas
adaline = Adaline(4)
# Treinamento
adaline.train(x, y)
## Test 1
A = [0.4329, -1.3719, 0.7022, -0.8535] # Versicolor (1)
predict = adaline.predict(A)
print('## Teste 1')
print('Entrada: ', A)
print('Classe esperada: Versicolor (1)')
if predict == 1:
print('Previsão: Versicolor (1)')
else:
print('Previsão: Setosa (-1)')
#=> 1
## Test 2
B = [0.3024, 0.2286, 0.8630, 2.7909] # Setosa (-1)
secondGroupOutput = [-1] * nSamplesPerGroup
inputData = np.concatenate((firstGroupInput, secondGroupInput))
outputData = np.concatenate((firstGroupOutput, secondGroupOutput))
trainIndexes, testIndexes = separateIndexesByRatio(2 * nSamplesPerGroup,
trainSamplesRatio)
random.shuffle(trainIndexes)
# %% Initialize and Train Adaline
adaline = Adaline([0] * (adalineDimension), 0.1, lambda x: 1 if x >= 0 else -1)
xTrain = inputData[trainIndexes]
yTrain = outputData[trainIndexes]
adaline.train(xTrain, yTrain, tol, maxIterations)
# %% Test
xTest = inputData[testIndexes]
yTest = outputData[testIndexes]
testResult = adaline.test(xTest, yTest)
print(f"Mean Squared Error: {testResult}")
# %% Plot
adalineApproxYArr = adaline.evaluate(inputData)
weights = adaline.getWeights()
def hyperPlan(x):
return -(weights[0] * x + weights[2]) / weights[1]
# Embaralhar
x = np.arange(len(d))
np.random.shuffle(x)
X_new = X[x]
d_new = d[x]
#print(d)
#print(d_new)
X_base_de_treinamento = X_new[:155,:]
d_base_de_treinamento = d_new[:155,:]
X_base_de_testes = X_new[155:,:]
d_base_de_testes = d_new[155:,:]
p = Adaline(len(X_base_de_treinamento[0]), epochs=1000)
p.train(X_base_de_treinamento, d_base_de_treinamento)
p.printMatrizparaMatriz(X_base_de_testes,d_base_de_testes)
p.printValoresParaPlanilha()
#p.printWeights
#p.restartWeights
#plt.xlim(-1,3)
#plt.ylim(-1,3)
#for i in range(len(d)):
# if d[i] == 1:
# plt.plot(X[i, 0], X[i, 1], 'ro')
# else:
# plt.plot(X[i, 0], X[i, 1], 'bo')
#f = lambda x: (p.weights[0]/p.weights[2]) - (p.weights[1]/p.weights[2] * x)
#vxH = list(range(-1,3))
for learning_rate in [0.2, 0.02, 0.002, 0.0002, 0.00002, 0.000002]:
print "Testing learning rate = %f" % learning_rate
data_indices = [idx for idx in xrange(data_instances.shape[0])]
# 10-fold cross validation
fold_size = (data_instances.shape[0]) / 10
total_performance = 0.0
for holdout_fold_idx in xrange(5):
# training_indices = data_indices - holdout_fold indices
training_indices = np.array(
np.setdiff1d(
data_indices,
data_indices[fold_size * holdout_fold_idx : \
fold_size * holdout_fold_idx + fold_size]))
# test_indices = holdout_fold indices
test_indices = np.array([
i for i in xrange(fold_size * holdout_fold_idx, fold_size *
holdout_fold_idx + fold_size)
])
model = Adaline(20.0, learning_rate)
# Train the model
model.train(data_instances[training_indices])
# Test performance on test set
predictions = model.predict(data_instances[test_indices, :-1])
total_performance += \
sum(predictions == data_instances[test_indices, -1]) / \
float(test_indices.shape[0])
print "Average overall classification rate: %f" % (total_performance /
10)
for i in range(len(errors_d2)):
ax2.plot(errors_d2[i], color=COLORS[i], label='eta = ' + str(etas[i]))
ax2.title.set_text('Learning Rate (Dataset 2)')
plt.legend()
plt.show()
# b. ADALINE
print '=== ADALINE ====='
# - DATASET 1
errors_d1, etas = [], [0.001, 0.003, 0.005, 0.007, 0.009]
for eta in etas:
adal_d1 = Adaline(2)
print '(D1) Training (eta =', eta, ')'
errors_d1.append(adal_d1.train(x1, y1, eta))
print '(D1) FINISHED\n==='
# - DATASET 2
errors_d2, etas = [], [0.001, 0.003, 0.005, 0.007, 0.009]
for eta in etas:
adal_d2 = Adaline(4)
print '(D2) Training (eta =', eta, ')'
errors_d2.append(adal_d2.train(x2, y2, eta))
print '(D2) FINISHED\n==='
# - plotting the learning rate for perceptron
fig = plt.figure()
ax1 = fig.add_subplot(121)
ax2 = fig.add_subplot(122)
plt.suptitle('Adaline')
def main():
xs = [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0]
ys = [2.26, 3.8, 4.43, 5.91, 6.18, 7.26, 8.15, 9.14, 10.87, 11.58, 12.55]
a_regression, b_regression, correlation_coefficient, _, regression_standard_error = linregress(
xs, ys)
regression_equation = f"y={a_regression:.5f}*x+{b_regression:.5f}"
ys_regression = [a_regression * x + b_regression for x in xs]
determination_coefficient = correlation_coefficient**2
print(f"Regression equation: {regression_equation}")
print(f"r = {correlation_coefficient:.5f}")
print(f"r² = {determination_coefficient:.5f}")
print(f"σ = {regression_standard_error:.5f}\n")
learning_rate = 0.0015
list_max_cycles = [100, 200, 500, 1000]
random_starting_weights = False
weight_adjustment_tolerance = None
square_error_tolerance = None
network = Adaline(learning_rate=learning_rate)
for source, target in zip(xs, ys):
network.add_sources([source], target)
adaline_plots = []
for max_cycles in list_max_cycles:
print(f"Max cycles: {max_cycles}\n--------------------------")
network.train(random_starting_weights=random_starting_weights,
max_cycles=max_cycles,
weight_adjustment_tolerance=weight_adjustment_tolerance,
square_error_tolerance=square_error_tolerance,
verbose=False)
a_adaline, b_adaline = network.neuron.weights[0], network.neuron.bias
adaline_equation = f"y={a_adaline:.5f}*x+{b_adaline:.5f}"
ys_adaline = [a_adaline * x + b_adaline for x in xs]
total_square_error = sum([(y - y_line)**2
for y, y_line in zip(ys, ys_adaline)])
adaline_standard_error = (total_square_error / len(ys))**0.5
print(f"Adaline equation: {adaline_equation}\n")
print(
f"Difference for a coefficient: {abs(a_adaline - a_regression):.5f}"
)
print(
f"Difference for b coefficient: {abs(b_adaline - b_regression):.5f}"
)
print(f"σ = {adaline_standard_error}\n-----------------------\n")
adaline_plots.append(
plt.plot(xs,
ys_adaline,
linestyle='--',
linewidth=3,
label=f"Cycles: {max_cycles}",
zorder=1)[0])
regression_plot, = plt.plot(xs,
ys_regression,
color='blue',
linestyle='-',
linewidth=5,
label=f"Regression: {regression_equation}",
zorder=0)
scatter_plot = plt.scatter(xs,
ys,
color='black',
marker='x',
s=80,
label='Source points',
zorder=2)
plt.legend(handles=[scatter_plot, *adaline_plots, regression_plot])
plt.show()
import numpy as np
from adaline import Adaline
x_train = np.random.randn(1000, 2)
x_test = np.random.randn(100, 2)
w = np.array([2, 16])
b = 18
y_train = np.dot(x_train, w) + b
y_test = np.dot(x_test, w) + b
adaline = Adaline(x_train.shape[1], 1e-3)
epochs = 10
batch_size = 10
for epoch in range(epochs):
for batch_idx in range(int(np.ceil(x_train.shape[0] / batch_size))):
batch_start_idx = batch_idx * batch_size
batch_end_idx = batch_start_idx + batch_size
if batch_end_idx > x_train.shape[0]:
batch_end_idx = x_train.shape[0]
adaline.train(x_train[batch_start_idx:batch_end_idx],
y_train[batch_start_idx:batch_end_idx])
print("weights:", adaline.weights)
print("bias:", adaline.bias)
print("root mean squared error on training set:",
adaline.root_mean_squared_error(x_train, y_train))
print("root mean squared error on testing set:",
adaline.root_mean_squared_error(x_test, y_test))
# Separando testDataset em valores e resultados
testInputs = testDataset[:, 0:(len(testDataset[0])-1)]
testOutputs = testDataset[:, (len(testDataset[0])-1):]
# Criando Adaline
#a = Adaline(len(trainInputs[0]), epochs=1000,learning_rate=0.0025, precision=0.000001)
a = Adaline(len(trainInputs[0]), epochs=1000,learning_rate=0.0025, precision=0.000001)
# Salvando Pesos Anteriores
oldWeights = ';'.join(['%.8f' % num for num in a.weights])
# Treinando Adaline
<<<<<<< HEAD
oldWeights = a.weights
qntEpochs, erro = a.train(trainInputs, trainOutputs)
newWeights = a.weights
=======
qntEpochs = a.train(trainInputs, trainOutputs)
# Salvando Pesos Novos
newWeights = ';'.join(['%.8f' % num for num in a.weights])
# Printando Pesos Antigos e Novos, e Quantidade de epocas utilizadas
>>>>>>> 51909512688e130709dd516ea800287b75f958d5
print(f'Adaline - Pesos Anterior: {oldWeights}')
print(f'Adaline - Pesos Atuais: {newWeights}')
print(f'Adaline - Quantidade Epochs utilizadas: {qntEpochs}')
print('')
# Prevendo valores
treino['d'] = treino['d'].astype('int')
teste = pd.read_csv('dados/dataset-teste.csv')
Y = treino['d'].values.copy()
X = treino[['x1', 'x2', 'x3', 'x4']].values.copy()
Resultado = teste.copy()
Treinamentos = pd.DataFrame()
hist_EQM = []
for i in range(5):
activation_function = Adaline.sign_function
adaline = Adaline(X, Y, 0.0025, activation_function)
wi, wf, ep, EQM = adaline.train()
hist_EQM.append(EQM)
wi = [round(x, 4) for x in wi]
wf = [round(x, 4) for x in wf]
w = np.concatenate(([wi], [wf], [[ep]]), axis=1)
Treino = pd.DataFrame(data=w,
columns=[
'Wi0', 'Wi1', 'Wi2', 'Wi3', 'Wi4', 'Wf0', 'Wf1',
'Wf2', 'Wf3', 'Wf4', 'N_Epocas'
],
index=[f'T{i+1}'])
Treinamentos = pd.concat([Treinamentos, Treino])
resultado_parcial = pd.DataFrame(columns=[f'T{i+1}'])
respostas = []
lenTrain = int(0.8 * len(dataset_Iris)
) #Define 80% dos dados para o treinamento e 20% para teste
X_Iris = X_new[0:lenTrain, 0:4]
D_Iris = D_new[0:lenTrain, 4:]
X_IrisTest = X_new[lenTrain:, 0:4]
D_IrisTest = D_new[lenTrain:, 4:]
#Adaline
#Adaline Iris
print('Rodando Adaline para dados - Iris')
a_Iris = Adaline(
len(X_Iris[0]), epochs=1000,
labelGraphic='Adaline - Iris') #epochs, quantidade de iteraçoes
a_Iris.train(X_Iris, D_Iris)
a_Iris.testNetwork(X_IrisTest, D_IrisTest)
a_Iris.Graphic()
a_Iris.showGraphic()
print('')
print('')
#Adaline Rochas
print('Rodando Adaline para dados - Rochas')
a_Rocha = Adaline(
len(X_Rochas[0]), epochs=1000,
labelGraphic='Adaline - Rochas') #epochs, quantidade de iteraçoes
a_Rocha.train(X_Rochas, D_Rochas)
a_Rocha.testNetwork(X_Rocha_teste, D_Rocha_teste)
a_Rocha.Graphic()
import pandas as pd
import matplotlib.pyplot as plt
from activation_functions import SignFunction
from adaline import Adaline
# Database dataset-treinamento:
dataset = pd.read_csv('database/dataset-treinamento_ADALINE.csv')
X = dataset.iloc[:, 0:4].values
d = dataset.iloc[:, 4:].values
adaline = Adaline(
X, d, 0.0025, 10**(-6), SignFunction
) # entrada, saída, taxa de ativação, precisão e função de ativação
values_eqm = adaline.train()
# Database dataset-teste:
dataset = pd.read_csv('database/dataset-teste_ADALINE.csv')
X_teste = dataset.iloc[:, 0:4].values
for x in X_teste:
y = adaline.evaluate(x)
print(f'Input: {x},Output: {y}')
# Plotando figura do problema
plt.plot(values_eqm)
plt.show()