def main():
#nn = NN([1,1], learning_rate=.1)
datos = np.genfromtxt("icgtp1datos/concentlite.csv", dtype=float, delimiter=',')
v_datos = convert_to_one_dimension(datos) #datos en una dimensión
particiones = particionar(v_datos, 5, .8, True)
v_datos_x = v_datos[:,0]
v_datos_y = v_datos[:,-1]
for _i in range(len(particiones)):
nn = NN([1,1], learning_rate=.1)
v_true = []
v_false = []
v_false_positive = []
v_false_negative = []
epocas_convergencia_iteracion = nn.Train(v_datos[particiones[_i][0]], max_epochs=150, tol_error=.1, alfa=0)
print(f"Epocas para convergencia en particion {_i+1}: {epocas_convergencia_iteracion+1}") #max_epochs = 150
outputs_particiones = []
for _p in particiones[_i][1]:
outputs_particiones.append(nn.Test(np.array([v_datos_x[_p]])))
cont_error = 0
cont = 0
for _k in particiones[_i][1]:
auxLabel = -1
if(outputs_particiones[cont]) > 0:
auxLabel = 1
v_true.append(_k)
else:
auxLabel = -1
v_false.append(_k)
if(auxLabel != v_datos_y[_k]):
if(v_datos_y[_k] == -1):
v_false_positive.append(_k)
else:
v_false_negative.append(_k)
cont_error += 1
cont += 1
errorPart = cont_error/len(outputs_particiones)
print("Error en partición "+repr(_i+1)+" -> "+repr(errorPart))
print(f"Cantidad de errores en particion: {cont_error} de {len(outputs_particiones)} patrones.")
print(f"Falsos positivos: {len(v_false_positive)} | Falsos negativos: {len(v_false_negative)}.")
print("\n")
plt.scatter(datos[v_true,0], datos[v_true,1], color=(1,0,0),label="Verdadero")
plt.scatter(datos[v_false,0], datos[v_false,1], color=(0,0,1),label="Falso")
plt.scatter(datos[v_false_positive,0], datos[v_false_positive,1], color=(0,1,0),label="Falso Positivo")
plt.scatter(datos[v_false_negative,0], datos[v_false_negative,1], color=(1,1,0),label="Falso Negativo")
plt.legend(loc="lower right", title="", frameon=False)
plt.title("Concentlite con una dimensión")
plt.show()
def main():
train = np.empty((1000, 28, 28), dtype='float64')
trainY = np.zeros((1000, 10, 1))
test = np.empty((10000, 28, 28), dtype='float64')
testY = np.zeros((10000, 10, 1))
# Load in the images
i = 0
for filename in os.listdir(
'C:/Users/anast/Documents/Deep Learning/Data/Training1000/'):
y = int(filename[0])
trainY[i, y] = 1.0
train[i] = cv2.imread(
'C:/Users/anast/Documents/Deep Learning/Data/Training1000/{0}'.
format(filename),
0) / 255.0 # 0 flag stands for greyscale; for color, use 1
i = i + 1
i = 0 # read test data
for filename in os.listdir(
'C:/Users/anast/Documents/Deep Learning/Data/Test10000/'):
y = int(filename[0])
testY[i, y] = 1.0
test[i] = cv2.imread(
'C:/Users/anast/Documents/Deep Learning/Data/Test10000/{0}'.format(
filename), 0) / 255.0
i = i + 1
trainX = train.reshape(train.shape[0], train.shape[1] * train.shape[2])
testX = test.reshape(test.shape[0], test.shape[1] * test.shape[2])
trainY = trainY.reshape(trainY.shape[0], trainY.shape[1])
testY = testY.reshape(testY.shape[0], testY.shape[1])
doBatchNorm = False
network = NN(trainX, trainY, [50, 10], ActivationType.RELU,
ActivationType.SOFTMAX)
#network.Train(GradientType.MINIBATCH,epochsNum=50,alpha=0.1,batchNorm=doBatchNorm,optimizer=OptimizerType.NONE)
network.Train(GradientType.MINIBATCH,
epochsNum=10,
alpha=0.01,
batchNorm=doBatchNorm,
optimizer=OptimizerType.ADAM,
Size=5)
accur = network.GetAccuracy(testX, testY, batchNorm=doBatchNorm)
print(accur)
from ReadClass import GetClass
from NN import NN
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
class_reader = GetClass()
filename = "Gene_Chip_Data/Gene_Chip_Data/microarray.original.txt"
classifier = NN(class_reader, filename, train_proportion=0.7)
(sess, accuracy, loss, input_data, label) = classifier.BuildGraph(30, 20, 15)
classifier.Train(sess,
accuracy,
loss,
input_data,
label,
batch_size=100,
train_time=500,
lr=1e-3)
classifier.Test(sess, accuracy, loss, input_data, label, batch_size=100)
def main():
#nn = NN([2,5,4,3], learning_rate=.2)#nn = NN([4,4,3], learning_rate=.1)
datos = np.genfromtxt("icgtp1datos/irisbin.csv", dtype=float, delimiter=',')
datos_area = Calcular_Area(datos)
patrones_test = 25
particiones = particionar_k_out(datos, patrones_test)
datos_x = datos_area[:,:-3]
datos_labels = datos[:,-3:]
v_errores_particiones = []
min_error = -1
v_c1_best = []
v_c2_best = []
v_c3_best = []
for _i in range(len(particiones)):
nn = NN([2,5,4,3], learning_rate=.2)#nn = NN([4,4,3], learning_rate=.1)
epocas_convergencia_iteracion = nn.Train(datos_area[particiones[_i][0]], max_epochs=100, tol_error=.1, alfa=0.5, tam_output=3)
outputs_particiones = []
cant_error = 0
v_clase1 = []
v_clase2 = []
v_clase3 = []
for _p in particiones[_i][1]:
#Salida de la red (devuelve una matriz de una fila con un vector con las salidas)
output = nn.Test(np.array(datos_x[_p]))
#Salida con 1 y -1s como una lista
output_wta = WinnerTakesAll(output[0][:])
#print(f"output_wta: {output_wta} || {datos_x[_p,0]} , {datos_x[_p,1]}, {datos_x[_p,2]}, {datos_x[_p,3]}")
#Agrego la salida al vector de salidas
outputs_particiones.append(output_wta)
clase_output = np.argmax(output_wta)
#print(f"clase: {clase_output}")
if(clase_output==0):
v_clase1.append(_p)
elif(clase_output == 1):
v_clase2.append(_p)
else:
v_clase3.append(_p)
#Si cualquiera es verdadero (distinto) entonces hay un error
if((output_wta!=datos_labels[_p]).any()):
cant_error += 1
error = cant_error / patrones_test
v_errores_particiones.append(error)
if(min_error == -1 or error < min_error):
min_error = error
v_c1_best = v_clase1
v_c2_best = v_clase2
v_c3_best = v_clase3
print(f"Error en particion {_i} {error}")
print(f"Media {np.mean(v_errores_particiones)}")
print(f"STD {np.std(v_errores_particiones)}")
plt.scatter(datos_x[v_c1_best,0], datos_x[v_c1_best,1], color=(1,0,0))
plt.scatter(datos_x[v_c2_best,0], datos_x[v_c2_best,1], color=(0,0,1))
plt.scatter(datos_x[v_c3_best,0], datos_x[v_c3_best,1], color=(0,1,0))
plt.show()
def main():
trainX, trainY, testX, testY = loadMatrices()
Digit_Classifier = NN([50, 10], ActivationType.RELU, 784)
Digit_Classifier.Train(trainX, trainY, epochs = 10, batch_size = 10, GradType = GradientDecentType.MINIBATCH, drop_out = True, learning_rate= 0.01, optimizer = 'Adam', batchnorm = True)
Digit_Classifier.test_accuracy(testX, testY)
def main():
datos = np.genfromtxt("datos/merval.csv", dtype=float, delimiter=',')
#(datos, max_dato) = utils.NormalizarDatos(datos)
# sigma = 25
sigma = np.std(datos)
print("STD sigma: ", sigma)
cant_patrones = datos.shape[0] - 5
max_dato = 1
m_datos = np.zeros((cant_patrones, 6))
k = 0
for i in range(cant_patrones):
m_datos[i, :] = datos[k:k + 6]
k += 1
#particion = utils.particionar(m_datos, 1, .2, random=False)
particiones = utils.particionar_k_out(m_datos, int(cant_patrones * 0.16))
fig, axs = plt.subplots(3, 2)
for nro_particion, particion in enumerate(particiones):
#Patrones y etiquetas de entrenamiento
m_inputs_trn = m_datos[particion[0], :-1]
v_labels_trn = m_datos[particion[0], -1:]
#Patrones y etiquetas de testeo
m_inputs_tst = m_datos[particion[1], :-1]
v_labels_tst = m_datos[particion[1], -1:]
neuronasRadiales = 10
nnMultiCapa = NN([neuronasRadiales, 1],
learning_rate=.05,
activation=utils.identidad,
dactivation=utils.identidad)
#Matriz de medias (tantas filas como neuronas radiales, y tantas columnas como dimension del problema)
idx = np.arange(m_inputs_trn.shape[0])
dimension = m_inputs_trn.shape[1]
medias = np.zeros((neuronasRadiales, dimension))
np.random.shuffle(idx)
#for i in range(neuronasRadiales):
# medias[i,:] = m_inputs_trn[idx[i]]
#Cantidad de patrones en cada conjunto
porConjunto = int(m_inputs_trn.shape[0] / neuronasRadiales)
for i in range(neuronasRadiales):
start = i * porConjunto
end = start + porConjunto
medias[i, :] = np.mean(m_inputs_trn[idx[start:end]])
asignaciones_ant = [1]
asignaciones = []
while (asignaciones != asignaciones_ant):
asignaciones_ant = asignaciones
asignaciones = []
for patron in m_inputs_trn:
distanciasPatronMedias = []
for media in medias:
distanciasPatronMedias.append(
np.sqrt(np.sum((media - patron)**2))
) #Raíz cuadrada de la suma de los cuadrados de las diferencias
min_idx = np.argmin(distanciasPatronMedias)
asignaciones.append(
min_idx
) #este vector me dice para cada patron, que media le corresponde
for idx_media in range(medias.shape[0]):
patronesMediaI = []
for i in range(len(asignaciones)):
if (asignaciones[i] == idx_media):
patronesMediaI.append(i)
m_inputs_media = m_inputs_trn[patronesMediaI]
#Si no hubo nuevas asignaciones en este conjunto, no cambiarlo
if (len(patronesMediaI) == 0):
x1_prom = medias[idx_media, 0]
x2_prom = medias[idx_media, 1]
x3_prom = medias[idx_media, 2]
x4_prom = medias[idx_media, 3]
x5_prom = medias[idx_media, 4]
else: #Si hubo cambios en el conjunto, recalcular media
x1_prom = np.mean(m_inputs_media[:, 0])
x2_prom = np.mean(m_inputs_media[:, 1])
x3_prom = np.mean(m_inputs_media[:, 2])
x4_prom = np.mean(m_inputs_media[:, 3])
x5_prom = np.mean(m_inputs_media[:, 4])
medias[idx_media, :] = [
x1_prom, x2_prom, x3_prom, x4_prom, x5_prom
]
#print(asignaciones)
#Tenemos todas las medias, hay que calcular las salidas de las gaussianas.
m_inputs_perceptron = np.zeros(
(m_inputs_trn.shape[0], neuronasRadiales))
for idx_p, p in enumerate(m_inputs_trn):
for idx_m, m in enumerate(medias):
m_inputs_perceptron[idx_p,
idx_m] = utils.gaussiana(p, m, sigma)
epocas_convergencia_iteracion = nnMultiCapa.Train(m_inputs_perceptron,
v_labels_trn,
max_epochs=1000,
tol_error=0.01)
print(f"Particion {nro_particion+1}")
print("Epocas para converger: ", epocas_convergencia_iteracion)
#TERMINA ENTRENAMIENTO
#------------------------------------------------------------------------------------------------------------------------
#TESTEO
#Feed fodward capa radial
m_inputs_test = np.zeros((m_inputs_tst.shape[0], neuronasRadiales))
for idx_p_test, p_test in enumerate(m_inputs_tst):
for idx_m, m in enumerate(medias):
m_inputs_test[idx_p_test,
idx_m] = utils.gaussiana(p_test, m, sigma)
#Feed fodward perceptrones simples
resultados = np.zeros(v_labels_tst.shape)
eficacias = []
for idx_p, p_test in enumerate(m_inputs_test):
resultados[idx_p] = nnMultiCapa.Test(p_test)[0, 0]
eficacia = resultados[idx_p] / v_labels_tst[idx_p]
eficacias.append(eficacia)
#print(f"Esperado: {v_labels_tst[idx_p]*max_dato} | Obtenido: {resultados[idx_p]*max_dato} | Eficacia: {eficacia} | Idx_p: {idx_p}")
#El mejor caso para la eficacia es que sea 1
#Lo esperado es que la media se encuentre cerca de 1
#Tener en cuenta que puede ser mayor a 1 (si la salida de la red es mas grande que la etiqueta) o menor a 1 (si la salida de la red es menor que la etiqueta)
print(f"Media Eficacias: {np.mean(eficacias)}")
#print(f"cant resultados: {resultados.shape} | cant etiq: {v_labels_tst.shape}")
ax = axs[int(nro_particion / 2), nro_particion % 2]
ax.scatter(np.arange(0, len(m_inputs_tst)),
resultados[:] * max_dato,
color=(1, 0, 0),
label="Prediccion")
ax.scatter(np.arange(0, len(m_inputs_tst)),
v_labels_tst[:] * max_dato,
color=(0, 1, 0),
label="Real")
ax.set_xlabel("Día")
ax.set_ylabel("Índice MERVAL")
plt.legend(loc="lower right", frameon=False)
fig.suptitle("Prediccion MERVAL RBF")
plt.show()
def main():
neuronasRadiales = 20
nnMultiCapa = NN([neuronasRadiales, 3], learning_rate=.3)
datos = np.genfromtxt("datos/irisbin.csv", dtype=float, delimiter=',')
particion = utils.particionar(datos, 1, .8, random=True)
#Patrones y etiquetas de entrenamiento
m_inputs_trn = datos[particion[0][0], :-3]
v_labels_trn = datos[particion[0][0], -3:]
#Patrones y etiquetas de testeo
m_inputs_tst = datos[particion[0][1], :-3]
v_labels_tst = datos[particion[0][1], -3:]
idx = np.arange(m_inputs_trn.shape[0])
dimension = m_inputs_trn.shape[1]
#Matriz de medias (tantas filas como neuronas radiales, y tantas columnas como dimension del problema)
medias = np.zeros((neuronasRadiales, dimension))
np.random.shuffle(idx)
#for i in range(neuronasRadiales):
# medias[i,:] = m_inputs_trn[idx[i]]
#Cantidad de patrones en cada conjunto
porConjunto = int(m_inputs_trn.shape[0] / neuronasRadiales)
for i in range(neuronasRadiales):
start = i * porConjunto
end = start + porConjunto
medias[i, :] = np.mean(m_inputs_trn[idx[start:end]])
asignaciones_ant = [1]
asignaciones = []
while (asignaciones != asignaciones_ant):
asignaciones_ant = asignaciones
asignaciones = []
for patron in m_inputs_trn:
distanciasPatronMedias = []
for media in medias:
distanciasPatronMedias.append(
np.sqrt(np.sum((media - patron)**2))
) #Raíz cuadrada de la suma de los cuadrados de las diferencias
min_idx = np.argmin(distanciasPatronMedias)
asignaciones.append(
min_idx
) #este vector me dice para cada patron, que media le corresponde
for idx_media in range(medias.shape[0]):
patronesMediaI = []
for i in range(len(asignaciones)):
if (asignaciones[i] == idx_media):
patronesMediaI.append(i)
m_inputs_media = m_inputs_trn[patronesMediaI]
#Si no hubo nuevas asignaciones en este conjunto, no cambiarlo
if (len(patronesMediaI) == 0):
x1_prom = medias[idx_media, 0]
x2_prom = medias[idx_media, 1]
x3_prom = medias[idx_media, 2]
x4_prom = medias[idx_media, 3]
else: #Si hubo cambios en el conjunto, recalcular media
x1_prom = np.mean(m_inputs_media[:, 0])
x2_prom = np.mean(m_inputs_media[:, 1])
x3_prom = np.mean(m_inputs_media[:, 2])
x4_prom = np.mean(m_inputs_media[:, 3])
medias[idx_media, :] = [x1_prom, x2_prom, x3_prom, x4_prom]
#print(asignaciones)
#Tenemos todas las medias, hay que calcular las salidas de las gaussianas.
m_inputs_perceptron = np.zeros((m_inputs_trn.shape[0], neuronasRadiales))
for idx_p, p in enumerate(m_inputs_trn):
for idx_m, m in enumerate(medias):
m_inputs_perceptron[idx_p, idx_m] = utils.gaussiana(p, m, 1)
epocas_convergencia_iteracion = nnMultiCapa.Train(m_inputs_perceptron,
v_labels_trn,
max_epochs=1000,
tol_error=.01)
#TERMINA ENTRENAMIENTO
#------------------------------------------------------------------------------------------------------------------------
#TESTEO
#Feed fodward capa radial
m_inputs_test = np.ones((m_inputs_tst.shape[0], neuronasRadiales))
for idx_p_test, p_test in enumerate(m_inputs_tst):
for idx_m, m in enumerate(medias):
m_inputs_test[idx_p_test, idx_m] = utils.gaussiana(p_test, m, 1)
#Feed fodward perceptrones simples
errores = []
v_clase1 = []
v_clase2 = []
v_clase3 = []
for idx_p, p_test in enumerate(m_inputs_test):
#Salida de la red con WinnerTakesAll
output = utils.WinnerTakesAll(nnMultiCapa.Test(p_test)[0][:])
#Error de la salida (error tiene 1s y 0s, si son todos 0 no hay error)
error = np.abs(output - v_labels_tst[idx_p])
if (sum(error) != 0):
errores.append(1)
else:
errores.append(0)
#Cómo fue clasificado el patrón
clase_output = np.argmax(output)
if (clase_output == 0):
v_clase1.append(idx_p)
elif (clase_output == 1):
v_clase2.append(idx_p)
else:
v_clase3.append(idx_p)
print(f"MEDIA ERROR: {np.mean(errores)}")
print(f"STD ERROR: {np.std(errores)}")
#Grafico de petalos
plt.scatter(m_inputs_tst[v_clase1, 0],
m_inputs_tst[v_clase1, 1],
color=(1, 0, 0),
label="Virginica")
plt.scatter(m_inputs_tst[v_clase2, 0],
m_inputs_tst[v_clase2, 1],
color=(0, 0, 1),
label="Versicolor")
plt.scatter(m_inputs_tst[v_clase3, 0],
m_inputs_tst[v_clase3, 1],
color=(0, 1, 0),
label="Setosa")
plot_circles = True
if (plot_circles):
for m in medias:
circle = plt.Circle((m[0], m[1]),
1,
fill=False,
edgecolor=(0, 0, 0),
linewidth='1')
plt.gca().add_patch(circle)
else:
plt.scatter(medias[:, 0],
medias[:, 1],
color=(0, 0, 0),
label="Centroides")
plt.xlabel("Ancho (cm)")
plt.ylabel("Alto (cm)")
plt.title("Pétalos RBF")
plt.legend(loc="lower right", frameon=False)
plt.show()
#Grafico de sepalos
plt.scatter(m_inputs_tst[v_clase1, 2],
m_inputs_tst[v_clase1, 3],
color=(1, 0, 0),
label="Virginica")
plt.scatter(m_inputs_tst[v_clase2, 2],
m_inputs_tst[v_clase2, 3],
color=(0, 0, 1),
label="Versicolor")
plt.scatter(m_inputs_tst[v_clase3, 2],
m_inputs_tst[v_clase3, 3],
color=(0, 1, 0),
label="Setosa")
if (plot_circles):
for m in medias:
circle = plt.Circle((m[2], m[3]),
1,
fill=False,
edgecolor=(0, 0, 0),
linewidth='1')
plt.gca().add_patch(circle)
else:
plt.scatter(medias[:, 2],
medias[:, 3],
color=(0, 0, 0),
label="Centroides")
plt.xlabel("Ancho (cm)")
plt.ylabel("Alto (cm)")
plt.legend(loc="lower right", frameon=False)
plt.title("Sépalos RBF")
plt.show()
def main():
#nn = NN([2,3,2,1], learning_rate=.1) # nn = NN([2,3,2,1], learning_rate=.2)
datos = np.genfromtxt("icgtp1datos/concentlite.csv", dtype=float, delimiter=',')
#Matriz de patrones sin etiquetas
m_inputs = datos[:,:-1]
#Vector de etiquetas de los patrones
v_labels = datos[:, -1]
particiones = particionar(datos, 5, .8, True)
min_error = -1
v_true_best = []
v_false_best = []
v_fn_best = []
v_fp_best = []
for _i in range(len(particiones)):
nn = NN([2,5,4,1], learning_rate=.2) # nn = NN([2,3,2,1], learning_rate=.2)
v_true = []
v_false = []
v_false_positive = []
v_false_negative = []
epocas_convergencia_iteracion = nn.Train(datos[particiones[_i][0]], max_epochs=300, tol_error=.25, alfa=0)
print(f"Epocas para convergencia en particion {_i+1}: {epocas_convergencia_iteracion+1}")
outputs_particiones = []
for _p in particiones[_i][1]:
outputs_particiones.append(nn.Test(m_inputs[_p]))
cont_error = 0
cont = 0
for _k in particiones[_i][1]:
auxLabel = -1
if(outputs_particiones[cont]) > 0:
auxLabel = 1
v_true.append(_k)
else:
auxLabel = -1
v_false.append(_k)
if(auxLabel != v_labels[_k]):
if(v_labels[_k] == -1):
v_false_positive.append(_k)
else:
v_false_negative.append(_k)
cont_error += 1
cont += 1
errorPart = cont_error/len(outputs_particiones)
print("Error en partición "+repr(_i+1)+" -> "+repr(errorPart))
print(f"Cantidad de errores en particion: {cont_error} de {len(outputs_particiones)} patrones.")
print(f"Falsos positivos: {len(v_false_positive)} | Falsos negativos: {len(v_false_negative)}.")
print("\n")
if(min_error == -1 or errorPart < min_error):
min_error = errorPart
v_true_best = v_true
v_false_best = v_false
v_fn_best = v_false_negative
v_fp_best = v_false_positive
plt.scatter(m_inputs[v_true_best,0], m_inputs[v_true_best,1], color=(1,0,0), label="Verdadero")
plt.scatter(m_inputs[v_false_best,0], m_inputs[v_false_best,1], color=(0,0,1), label="Falso")
plt.scatter(m_inputs[v_fp_best,0], m_inputs[v_fp_best,1], color=(0,1,0), label="Falso Positivo")
plt.scatter(m_inputs[v_fn_best,0], m_inputs[v_fn_best,1], color=(1,1,0), label="Falso Negativo")
plt.legend(loc="lower right", title="", frameon=False)
plt.title("Concentlite")
plt.show()
