def entrenar_adaline(self):
ratio_aprendizaje = self.sb_ratio.value()
epocas_maximas = self.sb_epocas.value()
error_minimo = self.sb_error.value()
entradas = np.array(self.datos.iloc[:,:-1].values.tolist())
clases = np.array(sum(self.datos.iloc[:,-1:].values.tolist(),[]))
pesos = np.random.rand(len(self.datos.columns)-1)
theta = np.random.rand()
self.btn_Entrenar.setEnabled(False)
self.adaline = Adaline(entradas, clases, ratio_aprendizaje, epocas_maximas, pesos, theta, error_minimo)
convergencia = self.adaline.entrenamiento(self)
if convergencia:
self.lbl_convergencia.setText("Sí convergió en " + str(self.adaline.epoca_actual) + " épocas")
self.pruebas.setEnabled(True)
self.btn_Predecir.setEnabled(True)
self.resultados.setEnabled(True)
else:
self.lbl_convergencia.setText("No convergió")
self.lbl_error_minimo.setText("El error mínimo alcanzado es: " + "{:10.4f}".format(self.adaline.errores[-1]))
self.graficar()
self.btn_Entrenar.setEnabled(True)
def test_bipolar_adaline(parameters):
parameters.activation_function = Adaline.bipolar_function
adaline = Adaline(parameters)
epochs = adaline.learn(learning_vectors_bipolar)
adaline.test(testing_vectors_bipolar)
return epochs
def main():
# Import data
#x_data, y_data = data.artificial2D()
x_data, y_data = data.artificial3D()
model = ad.Adaline(x_data, y_data)
model.adaline()
def test_run(neuron_t,
train_x,
train_y,
test_label,
activation,
lr,
init='range',
weight_range=None,
run_num=1):
epoch_nums = np.array([])
print(test_label)
x = 0
while x < run_num:
if neuron_t == 'perceptron':
neuron = Perceptron(2,
init=init,
weight_range=weight_range,
activation=activation)
else:
neuron = Adaline(2,
init=init,
weight_range=weight_range,
error_th=0.3)
neuron.train(train_x, train_y, learning_rate=lr)
epoch_nums = np.append(epoch_nums, neuron.epoch_num)
x += 1
average = np.average(epoch_nums)
std_deviation = np.sqrt(np.average((epoch_nums - average)**2))
print("AVG EPOCH NUM:", average)
print("STD DEVIATION:", std_deviation)
def __init__(self, parent=None):
super(MainWidget, self).__init__(parent)
self.isCurrExProper = False
self.pixelMap = np.array([-1.0 for i in range(ENTRANCES)])
self.currentAdalineIndex = 0
self.xmlParser = XMLParser()
self.examples = self.xmlParser.getAllExamples()
self.adalines = [
Adaline(myDigit=i, examples=self.examples, weightsCount=ENTRANCES)
for i in range(PERCEPTRONS)
]
#for perc in self.adalines:
# perc.setWeights(self.xmlParser.getWeights(perc.getMyDigit()))
self.setupUI()
def mainAdaline():
arquivoDTest = open("Dataset2/dtest2.txt", "r")
arquivoXTest = open("Dataset2/xtest2.txt", "r")
datasetTest = Dataset(arquivoDTest, arquivoXTest)
arquivoDTrain = open("Dataset2/dtrain2.txt", "r")
arquivoXTrain = open("Dataset2/xtrain2.txt", "r")
datasetTrain = Dataset(arquivoDTrain, arquivoXTrain)
redeAdalineTrain = Adaline(datasetTrain.definindoEntradas(),
datasetTrain.definindoValoresDesejados(),
taxa_aprendizado, precisao)
redeAdalineAnd = Adaline([[1, 1], [0, 0], [1, 0], [0, 1]], [1, -1, -1, -1],
0.25, 0.0001)
redeAdalineAnd.treinamento_online()
# redeAdalineTrain.treinamento_online()
redeAdalineAnd.conferirRespostas(redeAdalineAnd.x, redeAdalineAnd.w,
redeAdalineAnd.w0, redeAdalineAnd.d,
len(redeAdalineAnd.x))
class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow, MplWidget):
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent=parent)
self.setupUi(self)
self.ARCHIVO_BASE = 'divorce_reduced.csv'
self.btn_Entrenar.clicked.connect(self.entrenar_adaline)
self.btn_Predecir.clicked.connect(self.realizar_prediccion)
items = ['0','1','2','3','4']
self.cb_1.addItems(items)
self.cb_2.addItems(items)
self.cb_3.addItems(items)
self.cb_4.addItems(items)
self.cb_5.addItems(items)
self.cb_6.addItems(items)
self.cb_1.setCurrentIndex(0)
self.cb_2.setCurrentIndex(0)
self.cb_3.setCurrentIndex(0)
self.cb_4.setCurrentIndex(0)
self.cb_5.setCurrentIndex(0)
self.cb_6.setCurrentIndex(0)
# self.lineaErrores[1][-1] = 0
# self.lineaErrores[1] = np.append(self.lineaErrores[1][1:],0.0)
# grafica.cargarGrafica(self.ERROR_MAX, self.lineaErrores[0], self.lineaErrores[1], grafica.linea, False)
def normalizarDatos(self):
self.datos = self.datos.applymap(self.normalizar)
def normalizar(self, dato):
if dato >= 2:
dato = 1
else:
dato = 0
def leerArchivo(self):
mensaje = QtWidgets.QMessageBox()
mensaje.setIcon(QtWidgets.QMessageBox.Warning)
mensaje.setText("Falta el archivo " + self.ARCHIVO_BASE)
mensaje.setInformativeText("Es necesario que selecciones un archivo *.csv para continuar con la ejecución")
mensaje.setWindowTitle("Fallo la selección de archivo")
mensaje.setStandardButtons(QtWidgets.QMessageBox.Retry | QtWidgets.QMessageBox.Cancel)
mensaje.setDefaultButton(QtWidgets.QMessageBox.Retry)
orden = True
while orden:
try:
self.datos = pandas.read_csv(self.ARCHIVO_BASE)
return True
except FileNotFoundError:
orden = mensaje.exec_()
# 4194304 código de retorno para boton cancelar
if orden == 4194304:
orden = False
else:
nombre_archivo = QtWidgets.QFileDialog.getOpenFileName(self, "Abrir archivo", ".", "Procesos (*.csv)")
self.direccionArchivo = nombre_archivo
if nombre_archivo != "":
orden = False
self.datos = pandas.read_csv(nombre_archivo[0])
return True
else:
orden = mensaje.exec_()
# 4194304 código de retorno para boton cancelar
if orden == 4194304:
orden = False
return False
def entrenar_adaline(self):
ratio_aprendizaje = self.sb_ratio.value()
epocas_maximas = self.sb_epocas.value()
error_minimo = self.sb_error.value()
entradas = np.array(self.datos.iloc[:,:-1].values.tolist())
clases = np.array(sum(self.datos.iloc[:,-1:].values.tolist(),[]))
pesos = np.random.rand(len(self.datos.columns)-1)
theta = np.random.rand()
self.btn_Entrenar.setEnabled(False)
self.adaline = Adaline(entradas, clases, ratio_aprendizaje, epocas_maximas, pesos, theta, error_minimo)
convergencia = self.adaline.entrenamiento(self)
if convergencia:
self.lbl_convergencia.setText("Sí convergió en " + str(self.adaline.epoca_actual) + " épocas")
self.pruebas.setEnabled(True)
self.btn_Predecir.setEnabled(True)
self.resultados.setEnabled(True)
else:
self.lbl_convergencia.setText("No convergió")
self.lbl_error_minimo.setText("El error mínimo alcanzado es: " + "{:10.4f}".format(self.adaline.errores[-1]))
self.graficar()
self.btn_Entrenar.setEnabled(True)
def realizar_prediccion(self):
atr1 = int(self.cb_1.currentText())
atr2 = int(self.cb_2.currentText())
atr3 = int(self.cb_3.currentText())
atr4 = int(self.cb_4.currentText())
atr5 = int(self.cb_5.currentText())
atr6 = int(self.cb_6.currentText())
entradas = np.array([atr1, atr2, atr3, atr4, atr5, atr6])
dot = np.dot(entradas, self.adaline.pesos) + self.adaline.theta
if dot > 0:
self.resultado.setText("Resultado:\nSe van a divorciar")
else:
self.resultado.setText("Resultado:\nNo se van a divorciar")
def graficar(self):
# fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(8, 8))
# ax.plot(range(1, len(self.adaline.errores) + 1), self.adaline.errores)
# ax.set_xlabel('Épocas')
# ax.set_ylabel('Errores')
# ax.set_title('Adaline aplicado')
# plt.tight_layout()
# plt.show()
self.grafica_error.cargarGrafico(range(1, len(self.adaline.errores) + 1), self.adaline.errores)
import numpy as np
import matplotlib.pyplot as plt
from Adaline import Adaline
from random import uniform
def f(x):
return 3 * x + 2
X = np.random.rand(100, 1)
Y = [f(x) + uniform(-0.1, 0.1) for x in X]
f = Adaline(realizations=20, epochs=100, learningRate=0.1)
f.fit(X, Y)
w = f.w
MSE = f.MSE
RMSE = f.RMSE
print("f(x) = 3*x + 2")
print("MSE: {}, standardDeviation: {}".format(MSE["value"],
MSE["standardDeviation"]))
print("RMSE: {}, standardDeviation: {}".format(RMSE["value"],
RMSE["standardDeviation"]))
fig = plt.figure()
F = w[1] * X - w[0]
plt.plot(X, Y, "r.", X, F, "k")
plt.title("f(x) = {:.3f}*x + {:.3f}".format(w[1], -w[0]))
plt.xlabel("x")
plt.ylabel("f(x)")
'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data',
header=None)
df.tail()
import matplotlib.pyplot as plt
import numpy as np
y = df.iloc[0:100, 4].values
y = np.where(y == 'Iris-setosa', -1, 1)
X = df.iloc[0:100, [0, 2]].values
from Adaline import Adaline
from DecisionRegion import plot_decision_regions
fig, ax = plt.subplots(nrows=1, ncols=2, figsize=(8, 4))
ada1 = Adaline(n_iter=10, eta=0.01).fit(X, y)
ax[0].plot(range(1, len(ada1.cost_) + 1), np.log10(ada1.cost_), marker='o')
ax[0].set_xlabel('Epochs')
ax[0].set_ylabel('log(Sum-squared-error)')
ax[0].set_title('Adaline - Learning rate 0.01')
ada2 = Adaline(n_iter=10, eta=0.0001).fit(X, y)
ax[1].plot(range(1, len(ada2.cost_) + 1), np.log10(ada2.cost_), marker='o')
ax[1].set_xlabel('Epochs')
ax[1].set_ylabel('log(Sum-squared-error)')
ax[1].set_title('Adaline - Learning rate 0.0001')
plt.show()
X_std = np.copy(X)
X_std[:, 0] = (X[:, 0] - X[:, 0].mean()) / X[:, 0].std()
X_std[:, 1] = (X[:, 1] - X[:, 1].mean()) / X[:, 1].std()
# -*- coding: utf-8 -*-
#Se importa el csv
import csv
#Se importa Adaline
from Adaline import Adaline
#Se cogen los ficheros y los datos
fichero = open('datosEntrenamiento.csv', 'r')
datosFichero = csv.reader(fichero)
#Se guardan los datos en listas
datos = []
for fila in datosFichero:
datos.append(fila)
fichero = open('datosTest.csv', 'r')
datosFichero = csv.reader(fichero)
#Se guardan los datos para test
datosTest = []
for fila in datosFichero:
datosTest.append(fila)
rna = Adaline()
rna.train(datos)
error = rna.test(datosTest)
print "El error es de {}".format(error)
if vector[i] == 0:
vector[i] = -1
### dane wejsciowe
INPUTS = 7
LETTTER_NUMBER = 10
ERAS = 0
LEARNING_RATE = 0.00001
ADALINES = []
CORRECT = [] # -1 --> duża litera, 1 --> mała litera
RESULT = [] # dane wyjsciowe (wyniki testowania)
for i in range(0, INPUTS):
ADALINES.append(Adaline(INPUTS))
for i in range(0, LETTTER_NUMBER):
CORRECT.append(-1)
for i in range(LETTTER_NUMBER, 2 * LETTTER_NUMBER):
CORRECT.append(1)
for i in range(0, 2 * LETTTER_NUMBER):
RESULT.append(0)
while RESULT != CORRECT:
for i in range(0, 2):
for j in range(0, LETTTER_NUMBER):
learn(ADALINES, INPUTS, LEARNING_RATE, i, j)
Y=data[:,2]
Xtrain, Xtest, Ytrain, Ytest = train_test_split(X, Y, test_size=0.33, random_state=42)
n,dim = X.shape
if model == 1:
lr = float(input('Give learning rate:'))
epochs = int(input('Give number of epochs:'))
ppn = Perceptron(lr,epochs,2,problem)
ppn.plot_of_inputs(data)
ppn.fit(Xtrain,Ytrain)
y_predicted = ppn.predict(Xtest)
# ppn.plot_of_outputs(Ytest,y_predicted)
print('Accuracy:',ppn.calc_acc(Ytest,y_predicted))
elif model == 2:
lr = float(input('Give learning rate:'))
epochs = int(input('Give number of epochs:'))
adaline = Adaline(100,0.01,0.1,2)
adaline.fit(Xtrain,Ytrain)
print(adaline.predict(Xtest))
elif model == 3:
activation = str(input('Give activation function:'))
maxEpochs = int(input('Give max epochs'))
plot_of_inputs(data,dim)
mlp = MLPClassifier(1,activation,max_iter=100, alpha=1e-4,
solver='sgd', verbose=10, random_state=1,
learning_rate_init=.1)
mlp.fit(Xtrain, Ytrain)
print(mlp.predict(Xtest))
elif problem == 2:
mse = [] # mean square error
rmse = [] # root mean square error
data = utils.normalize(data)
models = {}
for i in range(realizations):
np.random.shuffle(data)
train_set, test_set = np.split(data, [int(.8 * len(data))]) # Split data in train(80%) and test(20%)
# Train
start = time.time()
adaline = Adaline()
adaline.fit(train_set)
end = time.time()
times_train.append(end - start) # Getting time of training
# Test
start = time.time()
predicted = adaline.predict(test_set[:, :-1])
end = time.time()
times_test.append(end - start) # Getting time of test
Y_true = test_set[:, -1]
mse.append(np.mean((Y_true - predicted)**2))
rmse.append(np.sqrt(mse[-1]))