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()
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(): 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()