def generar_conjunto_aleatorio(rango,
                               dim,
                               tam,
                               separable=True,
                               clases=None,
                               pesos=None):
    hiperplano = None
    if pesos is None:
        hiperplano = Clasificador.genera_pesos(dim)
    else:
        hiperplano = pesos
    conjunto = []
    soluciones = []
    for i in range(0, tam):
        atributos = []
        for j in range(0, dim):
            atributos.append(random.randint(-rango, rango))
        prediccion = Clasificador.calcular_prediccion(atributos,
                                                      hiperplano,
                                                      None,
                                                      is_sigma=False)
        conjunto.append(atributos)
        if clases != None:
            soluciones.append(clases[prediccion])
        else:
            soluciones.append(prediccion)
    if not separable:
        soluciones = altera_soluciones(soluciones, rango)
    return (hiperplano, conjunto, soluciones)
Example #2
0
def entrena(conjunto,
            resultados,
            clases,
            n_epochs,
            rate_inicial,
            pesos_iniciales,
            rate_decay,
            summary=None):
    pesos = None
    rate = rate_inicial
    if pesos_iniciales == None:
        pesos = clasificador.genera_pesos(len(conjunto[0]))
    else:
        pesos = pesos_iniciales
    epoch = 0
    n_errors = 1
    while epoch < n_epochs and n_errors != 0:
        n_errors = 0
        for index in range(0, len(conjunto)):
            prediccion = clasificador.calcular_prediccion(conjunto[index],
                                                          pesos,
                                                          clases,
                                                          is_sigma=False)
            if prediccion != resultados[index]:
                n_errors += 1
            pesos = ajusta_pesos(
                conjunto[index], pesos,
                clasificador.busca_resultado(resultados[index], clases), rate)
        if rate_decay:
            rate = clasificador.decaer_ratio(rate_inicial, epoch)
        if summary != None:
            summary.add_epoch(n_errors / len(conjunto))
        epoch += 1
    return pesos
Example #3
0
regre_batch = regresion.Regresion(Votos.votos_clases,
                                  norm=normalizar,
                                  estocastico=False)
regre_batch.entrena(Votos.votos_entr,
                    Votos.votos_entr_clas,
                    1000,
                    rate_decay=True)
regre_batch.summary.imprime_error()
regre_batch.summary.imprime_magnitud()

print("Regresion batch: ", regre_batch.imprime())
print("Regresion batch: ",
      regre_batch.evalua(Votos.votos_valid, Votos.votos_valid_clas))

print("Otras pruebas")
print(Clasificador.genera_pesos(5))
# Pesos mejores para votos, probabilidad con validacion de 0.9710144927536232
mejor_votos = [
    0.03724722117863166, 0.07855852078341741, -0.04431696109736549,
    0.016418011251744247, -0.23789171693988465, -0.042607598132008206,
    -0.014111082392901153, 0.021817553749997387, 0.04786968628491195,
    0.0650495427619262, -0.049239096885685285, -0.015182104323912426,
    -0.07350127226732184, -0.03564717793892669, -0.00531360899617539,
    0.03314275012576218, -0.021657938490079687
]

perceptron.entrena(Votos.votos_entr,
                   Votos.votos_entr_clas,
                   1000,
                   pesos_iniciales=mejor_votos,
                   rate_decay=False)