def main():
tictac = Datos("tic-tac-toe.data")
#Analisis ROC
print("\nValidando 100 veces con clasificador propio:")
for _ in range(0, 100):
nb = ClasificadorNaiveBayes()
vs = ValidacionSimple()
vs.creaParticiones(tictac.datos)
particiones = vs.particiones
nb.entrenamiento(tictac.extraeDatos(particiones[0].indicesTrain),
tictac.nominalAtributos, tictac.diccionario)
datosTest = tictac.extraeDatos(particiones[0].indicesTest)
pred, pred_lap = nb.clasifica(datosTest, tictac.nominalAtributos,
tictac.diccionario)
clase = datosTest[:, len(tictac.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, pred)
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
print("DatosROC:")
print(tpr)
print(fpr)
print(str(tp) + " " + str(tn) + " " + str(fp) + " " + str(fn))
def main():
dataset_example4 = Datos('example4.data')
VS_example4 = ValidacionSimple(0.7)
VS_example4.creaParticiones(dataset_example4)
reg = ClasificadorRegresionLogistica(0.1, 100)
reg.entrenamiento(dataset_example4,
VS_example4.particiones[0].indicesTrain)
x = dataset_example4.datos[VS_example4.particiones[0].indicesTrain, 0]
y = dataset_example4.datos[VS_example4.particiones[0].indicesTrain, 1]
clase = dataset_example4.datos[VS_example4.particiones[0].indicesTrain,
-1] != 0
plotModel(x, y, clase, reg, "-- Fronteras REGRESION -- EXAMPLE4 --")
from Datos import Datos from EstrategiaParticionado import EstrategiaParticionado from EstrategiaParticionado import Particion from EstrategiaParticionado import ValidacionCruzada from EstrategiaParticionado import ValidacionSimple from EstrategiaParticionado import ValidacionBootstrap from ClasificadorAG import ClasificadorAG path1 = "data/wdbc.data" path2 = "data/tic-tac-toe.data" dataset = Datos(path1) dataset2 = Datos(path2) estrategia = ValidacionSimple() estrategia.creaParticiones(dataset, 0.8) estrategia2 = ValidacionSimple() estrategia2.creaParticiones(dataset2, 0.8) #clasificador=ClasificadorAG(reglas_iniciales=1) clasificador = ClasificadorAG(binaria=False, reglas_iniciales=1) """ ii = estrategia.particiones[-1].indicesTrain plotModel(dataset_wdbc.datos[ii, 0], dataset_wdbc.datos[ii, 1], dataset_wdbc.datos[ii, -1] != 0, clasificador, "RL LR=1;EPOC=10", dataset_wdbc.diccionarios) print(clasificador.validacion(estrategia, dataset, clasificador)) print(clasificador.validacion(estrategia2, dataset2, clasificador))""" clasificador.entrenamiento(
def main():
tictac = Datos("tic-tac-toe.data")
german = Datos("german.data")
print("Tic-tac-toe:\n")
print("nominalAtributos:")
print(tictac.nominalAtributos)
print("\nDiccionario:")
print(tictac.diccionario)
print("\nDatos:")
print(tictac.datos)
print("\n\nTicTacToe:")
print("\nValidación Simple")
print("\nValidando 100 veces con clasificador propio:")
error = 0
error_lap = 0
for _ in range(0, 100):
nb = ClasificadorNaiveBayes()
vs = ValidacionSimple()
ret = Clasificador.validacion(vs, tictac, nb)
error += ret[0]
error_lap += ret[1]
print("Error medio sin laplace " + str(error / 100))
print("Error medio con laplace " + str(error_lap / 100))
print("\nValidando 100 veces con MultinomialNB:")
enc = OneHotEncoder(sparse=False)
tictac.datos = enc.fit_transform(tictac.datos)
atr = tictac.datos[:, :len(tictac.nominalAtributos) - 1]
clase = tictac.datos[:, len(tictac.nominalAtributos) - 1]
error = 0
for _ in range(0, 100):
train_x, test_x, train_y, test_y = train_test_split(atr, clase, test_size=0.1)
nb = MultinomialNB()
nb.fit(train_x, train_y)
res = nb.predict(test_x)
error += error_sk(test_y, res)
print("Error medio " + str(error / 100))
print("\nValidando 100 veces con GaussianNB:")
enc.inverse_transform(tictac.datos)
atr = tictac.datos[:, :len(tictac.nominalAtributos) - 1]
clase = tictac.datos[:, len(tictac.nominalAtributos) - 1]
error = 0
for _ in range(0, 100):
train_x, test_x, train_y, test_y = train_test_split(atr, clase, test_size=0.1)
nb = GaussianNB()
nb.fit(train_x, train_y)
res = nb.predict(test_x)
error += error_sk(test_y, res)
print("Error medio " + str(error / 100))
###################################################################################################################
print("\nValidacion Cruzada")
print("\nValidando con clasificador propio:")
tictac = Datos("tic-tac-toe.data")
nb = ClasificadorNaiveBayes()
vc = ValidacionCruzada()
error = Clasificador.validacion(vc, tictac, nb)
print("Error medio sin laplace " + str(error[0]))
print("Error medio con laplace " + str(error[1]))
print("\nValidando con MultinomialNB:")
enc = OneHotEncoder(sparse=False)
tictac.datos = enc.fit_transform(tictac.datos)
atr = tictac.datos[:, :len(tictac.nominalAtributos) - 1]
clase = tictac.datos[:, len(tictac.nominalAtributos) - 1]
acierto = cross_val_score(MultinomialNB(), atr, clase)
error = []
for data in acierto:
error.append(1 - data)
print("Error por particiones: ")
print(error)
total_err = sum(error) / len(error)
print("Error medio: " + str(total_err))
print("\nValidando con GaussianNB:")
enc.inverse_transform(tictac.datos)
atr = tictac.datos[:, :len(tictac.nominalAtributos) - 1]
clase = tictac.datos[:, len(tictac.nominalAtributos) - 1]
acierto = cross_val_score(GaussianNB(), atr, clase)
error = []
for data in acierto:
error.append(1 - data)
print("Error por particiones: ")
print(error)
total_err = sum(error) / len(error)
print("Error medio: " + str(total_err))
#######################################################################################################################
print("\n\nGerman:\n")
print("nominalAtributos:")
print(german.nominalAtributos)
print("\nDiccionario:")
print(german.diccionario)
print("\nDatos:")
print(german.datos)
print("\n\nGerman:")
print("\nValidacion Simple")
print("\nValidando 100 veces con clasificador propio:")
error = 0
error_lap = 0
for _ in range(0, 100):
nb = ClasificadorNaiveBayes()
vs = ValidacionSimple()
ret = Clasificador.validacion(vs, german, nb)
error += ret[0]
error_lap += ret[1]
print("Error medio sin laplace " + str(error / 100))
print("Error medio con laplace " + str(error_lap / 100))
print("\nValidando 100 veces con MultinomialNB:")
#En este caso no pretratamos los datos pues los transformaría todos en datos nominales y en este caso hay datos continuos
atr = german.datos[:, :len(german.nominalAtributos) - 1]
clase = german.datos[:, len(german.nominalAtributos) - 1]
error = 0
for _ in range(0, 100):
train_x, test_x, train_y, test_y = train_test_split(atr, clase, test_size=0.1)
nb = MultinomialNB()
nb.fit(train_x, train_y)
res = nb.predict(test_x)
error += error_sk(test_y, res)
print("Error medio " + str(error / 100))
print("\nValidando 100 veces con GaussianNB:")
atr = german.datos[:, :len(german.nominalAtributos) - 1]
clase = german.datos[:, len(german.nominalAtributos) - 1]
error = 0
for _ in range(0, 100):
train_x, test_x, train_y, test_y = train_test_split(atr, clase, test_size=0.1)
nb = GaussianNB()
nb.fit(train_x, train_y)
res = nb.predict(test_x)
error += error_sk(test_y, res)
print("Error medio " + str(error / 100))
###################################################################################################################
print("\nValidacion Cruzada")
print("\nValidando con clasificador propio:")
german = Datos("german.data")
nb = ClasificadorNaiveBayes()
vc = ValidacionCruzada()
error = Clasificador.validacion(vc, german, nb)
print("Error medio sin laplace " + str(error[0]))
print("Error medio con laplace " + str(error[1]))
print("\nValidando con MultinomialNB:")
#En este caso no pretratamos los datos pues los transformaría todos en datos nominales y en este caso hay datos continuos
atr = german.datos[:, :len(german.nominalAtributos) - 1]
clase = german.datos[:, len(german.nominalAtributos) - 1]
acierto = cross_val_score(MultinomialNB(), atr, clase)
error = []
for data in acierto:
error.append(1 - data)
print("Error por particiones: ")
print(error)
total_err = sum(error) / len(error)
print("Error medio: " + str(total_err))
print("\nValidando con GaussianNB:")
atr = german.datos[:, :len(german.nominalAtributos) - 1]
clase = german.datos[:, len(german.nominalAtributos) - 1]
acierto = cross_val_score(GaussianNB(), atr, clase)
error = []
for data in acierto:
error.append(1 - data)
print("Error por particiones: ")
print(error)
total_err = sum(error) / len(error)
print("Error medio: " + str(total_err))
if (len(sys.argv) < 6):
print("Instrucciones de ejecucion:")
print(
"python main.py <ficheroEntrada> <ficheroSalida> <porcentajeEntrenamiento> <tasaAprendizaje> <numNeuronasOculta>"
)
sys.exit()
fichero_entrada = str(sys.argv[1])
fichero_salida = str(sys.argv[2])
porcentaje = float(sys.argv[3])
tasaAprendizaje = float(sys.argv[4])
numNeuronas = int(sys.argv[5])
Na = 5
Ns = 1
adaptaficheroserie(fichero_entrada, fichero_salida, Na, Ns)
dat = Datos(fichero_salida, True)
val = ValidacionSimple(porcentaje)
clas1 = SerieTemporal(numNeuronas, tasaAprendizaje)
errores1 = clas1.validacion(val,
dat,
clas1,
random=False,
salida="pesos.txt",
recursivo=False)
print "El ECM en la particion test del clasificador es: "
print str((errores1[0]))
print ""
import sys
from tabulate import tabulate
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
if __name__ == "__main__":
############################## TIC TAC TOE ###########################################
fileName = "ConjuntosDatos/tic-tac-toe.data"
datos_tic = Datos(fileName)
# Probamos con 75 porciento y 10 iteraciones (Validacion Simple)
validacion_simple_tic = ValidacionSimple(75,10)
aux_simple_tic = validacion_simple_tic.creaParticiones(datos_tic)
# Probamos con 10 k-iteraciones
validacion_cruzada_tic = ValidacionCruzada(6)
aux_cruzada_tic = validacion_cruzada_tic.creaParticiones(datos_tic)
Clasificador = ClasificadorNaiveBayes()
media_error1, media_tp1, media_fp1, media_tn1, media_fn1 = Clasificador.validacion(validacion_simple_tic,datos_tic,True)
media_error2, media_tp2, media_fp2, media_tn2, media_fn2 = Clasificador.validacion(validacion_cruzada_tic,datos_tic,True)
############################## GERMAN DATA ###########################################
fileName = "ConjuntosDatos/german.data"
datos_ger = Datos(fileName)
from Distancias import *
from Verificador import *
from MatrizConfusion import MatrizConfusion
from tabulate import tabulate
if __name__ == "__main__":
# Abrimos los ficheros y extraemos los datos
fileName = "ConjuntosDatos/pima-indians-diabetes.data"
datos_diabetes = Datos(fileName)
fileName = "ConjuntosDatos/wdbc.data"
datos_wdbc = Datos(fileName)
# Creamos las validaciones
validacion_simple_diabetes = ValidacionSimple(75, 10)
#simple_diabetes = validacion_simple_diabetes.creaParticiones(datos_diabetes)
validacion_cruzada_diabetes = ValidacionCruzada(6)
#cruzada_diabetes = validacion_cruzada_diabetes.creaParticiones(datos_diabetes)
validacion_simple_wdbc = ValidacionSimple(75, 10)
#simple_wdbc = validacion_simple_wdbc.creaParticiones(datos_wdbc)
validacion_cruzada_wdbc = ValidacionCruzada(6)
#cruzada_wdbc = validacion_cruzada_wdbc.creaParticiones(datos_wdbc)
""" Distancia de Mahalanobis """
"""nn = ClasificadorVecinosProximos(1, Mahalanobis)
medias_cruzadas_diabetes_knn_1 = knn.validacion(validacion_cruzada_diabetes, datos_wdbc)
dataset = Datos('ConjuntosDatos/german.data')
#dataset=Datos('ConjuntosDatos/tic-tac-toe.data')
print("----Pruebas P1")
print(dataset.nombreAtributos)
print(dataset.tipoAtributos)
print(dataset.nominalAtributos)
print(dataset.datos)
print("----Pruebas P2")
d1 = Datos('ConjuntosDatos/german.data')
d2 = Datos('ConjuntosDatos/tic-tac-toe.data')
NB = ClasificadorNaiveBayes()
print("VALIDACION SIMPLE (german.data): ")
v_simple = ValidacionSimple('ValidacionSimple', 3, 0.8)
p = v_simple.creaParticiones(d1.datos)
for k in p:
print("Indices Test: ")
print(k.indicesTest)
print("Indices Train: ")
print(k.indicesTrain)
print("----")
print(v_simple.nombreEstrategia)
print("-----------------------")
print("VALIDACION CRUZADA (german.data): ")
v_cross = ValidacionCruzada('ValidacionCruzada', 5)
p = v_cross.creaParticiones(d1.datos)
for k in p:
print("Indices Test: ")
#from sklearn import cross_validation
#from sklearn.naive_bayes import MultinomialNB
#from sklearn.naive_bayes import GaussianNB
import numpy as np
import matplotlib.pyplot as plt
#from sklearn.neighbors import KNeighborsClassifier
#from sklearn.linear_model import LogisticRegression
from Clasificador import ClasificadorRegLog
from Clasificador import AlgoritmoGenetico
from copy import deepcopy
dat = Datos("ejemplo5.data", True)
dat2 = deepcopy(dat)
val = ValidacionSimple()
# Instancia el algoritmo con el que quieres clasificar
clas = AlgoritmoGenetico()
#---------AG PROPIO-----------#
errores = clas.validacion(val, dat, clas)
print(str(clas.generaciones) + " Generaciones con " + str(clas.poblacion) + " individuos y numero de reglas " + str(clas.num_reglas))
print ("Algoritmo Genetico, tasa de error:", errores[0])
print "Mejor individuo (1 regla):"
print(clas.mejor_individuo)
print "Fitness medio por generacion:"
print(clas.fitness_medio_gen)
def main():
titanic = Datos("titanic.data", allNominal=True)
print("Titanic:\n")
print("nominalAtributos:")
print(titanic.nominalAtributos)
print("\nDiccionario:")
print(titanic.diccionario)
print("\nDatos:")
print(titanic.datos)
##################################################################################################################
# HALLAR MEJORES PROBABILIDADES Y TAMAÑO DE REGLA (NO EJECUTAR, sale tamaño de regla 10, y ambas probs 1)
#args = {"epocas": 100, "pob_size": 50, "max": 3, "prob_cruce": 0.5, "prob_mutacion": 0.1, "plot": False}
#best_err = 1
#best_args = {}
#for max_reg in range(1, 11):
# args["max"] = max_reg
# gen = ClasificadorGenetico()
# vs = ValidacionSimple()
# error = Clasificador.validacion(vs, titanic, gen, args=args)
# if error[0] < best_err:
# best_err = error[0]
# best_args = args
#args["max"] = best_args["max"]
#best_err = 1
#best_args = {}
#for prob_cruce in np.arange(0, 1, 0.05):
# args["prob_cruce"] = prob_cruce
# gen = ClasificadorGenetico()
# vs = ValidacionSimple()
# error = Clasificador.validacion(vs, titanic, gen, args=args)
# if error[0] < best_err:
# best_err = error[0]
# best_args = args
#args["prob_cruce"] = best_args["prob_cruce"]
#for prob_mutacion in np.arange(0, 1, 0.05):
# args["prob_mutacion"] = prob_mutacion
# gen = ClasificadorGenetico()
# vs = ValidacionSimple()
# error = Clasificador.validacion(vs, titanic, gen, args=args)
# # print("Error medio " + str(error[0]))
# if error[0] < best_err:
# best_err = error[0]
# best_args = args
#print(str(best_args))
###################################################################################################################
# Representamos la evolución del best fit (usamos probabilidades y tamaño de regla mucho más bajas para reducir tiempo de ejecución)
args = {
"epocas": 100,
"pob_size": 50,
"max": 3,
"prob_cruce": 0.5,
"prob_mutacion": 0.3,
"plot": True
}
print("\n\nTitanic:")
print("\nValidación Simple, Población 50, 100 épocas")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
error = Clasificador.validacion(vs, titanic, gen, args=args)
print("\nError medio: " + str(error[0]) + "\n")
args["epocas"] = 200
print("\nValidación Simple, Población 50, 200 épocas")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
error = Clasificador.validacion(vs, titanic, gen, args=args)
print("\nError medio: " + str(error[0]) + "\n")
args["epocas"] = 100
args["pob_size"] = 150
print("\nValidación Simple, Población 150, 100 épocas")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
error = Clasificador.validacion(vs, titanic, gen, args=args)
print("\nError medio: " + str(error[0]) + "\n")
args["epocas"] = 200
print("\nValidación Simple, Población 150, 200 épocas")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
error = Clasificador.validacion(vs, titanic, gen, args=args)
print("\nError medio: " + str(error[0]) + "\n")
###################################################################################################################
# Análisis ROC
args = {
"epocas": 100,
"pob_size": 50,
"max": 3,
"prob_cruce": 0.5,
"prob_mutacion": 0.3,
"plot": False
}
print("50-100")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
vs.creaParticiones(titanic.datos)
particiones = vs.particiones
gen.entrenamiento(titanic.extraeDatos(particiones[0].indicesTrain),
titanic.nominalAtributos, titanic.diccionario, args)
datosTest = titanic.extraeDatos(particiones[0].indicesTest)
result = gen.clasifica(datosTest, titanic.nominalAtributos,
titanic.diccionario)
clase = datosTest[:, len(titanic.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, result[0])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
X_50_100 = fpr
Y_50_100 = tpr
args["pob_size"] = 150
print("150-100")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
vs.creaParticiones(titanic.datos)
particiones = vs.particiones
gen.entrenamiento(titanic.extraeDatos(particiones[0].indicesTrain),
titanic.nominalAtributos, titanic.diccionario, args)
datosTest = titanic.extraeDatos(particiones[0].indicesTest)
result = gen.clasifica(datosTest, titanic.nominalAtributos,
titanic.diccionario)
clase = datosTest[:, len(titanic.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, result[0])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
X_150_100 = fpr
Y_150_100 = tpr
args["pob_size"] = 50
args["epocas"] = 200
print("50-200")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
vs.creaParticiones(titanic.datos)
particiones = vs.particiones
gen.entrenamiento(titanic.extraeDatos(particiones[0].indicesTrain),
titanic.nominalAtributos, titanic.diccionario, args)
datosTest = titanic.extraeDatos(particiones[0].indicesTest)
result = gen.clasifica(datosTest, titanic.nominalAtributos,
titanic.diccionario)
clase = datosTest[:, len(titanic.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, result[0])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
X_50_200 = fpr
Y_50_200 = tpr
args["pob_size"] = 150
print("150-200")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
vs.creaParticiones(titanic.datos)
particiones = vs.particiones
gen.entrenamiento(titanic.extraeDatos(particiones[0].indicesTrain),
titanic.nominalAtributos, titanic.diccionario, args)
datosTest = titanic.extraeDatos(particiones[0].indicesTest)
result = gen.clasifica(datosTest, titanic.nominalAtributos,
titanic.diccionario)
clase = datosTest[:, len(titanic.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, result[0])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
X_150_200 = fpr
Y_150_200 = tpr
print("NB")
nb = ClasificadorNaiveBayes()
vs = ValidacionSimple()
vs.creaParticiones(titanic.datos)
particiones = vs.particiones
nb.entrenamiento(titanic.extraeDatos(particiones[0].indicesTrain),
titanic.nominalAtributos, titanic.diccionario)
datosTest = titanic.extraeDatos(particiones[0].indicesTest)
result = nb.clasifica(datosTest, titanic.nominalAtributos,
titanic.diccionario)
clase = datosTest[:, len(titanic.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, result[0])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
X_nb = fpr
Y_nb = tpr
plt.figure()
lw = 2
plt.plot(X_50_100, Y_50_100, "ro", lw=lw, label="Gen 50-100")
plt.plot(X_150_100, Y_150_100, "go", lw=lw, label="Gen 150-100")
plt.plot(X_50_200, Y_50_200, "bo", lw=lw, label="Gen 50-200")
plt.plot(X_150_200, Y_150_200, "yo", lw=lw, label="Gen 150-200")
plt.plot([0, X_nb, 1], [0, Y_nb, 1], color="deeppink", lw=lw, label="NB")
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel("fpr")
plt.ylabel("tpr")
plt.title("ROC Titanic")
plt.legend(loc="lower right")
plt.show()
########################################################################################################################
# REPETIMOS PARA TICTACTOE
tictac = Datos("tic-tac-toe.data", allNominal=True)
print("Tic-tac-toe:\n")
print("nominalAtributos:")
print(tictac.nominalAtributos)
print("\nDiccionario:")
print(tictac.diccionario)
print("\nDatos:")
print(tictac.datos)
# Representamos la evolución del best fit (usamos probabilidades y tamaño de regla mucho más bajas para reducir tiempo de ejecución)
args = {
"epocas": 100,
"pob_size": 50,
"max": 3,
"prob_cruce": 0.5,
"prob_mutacion": 0.3,
"plot": True
}
print("\n\nTic-tac-toe:")
print("\nValidación Simple, Población 50, 100 épocas")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
error = Clasificador.validacion(vs, tictac, gen, args=args)
print("\nError medio: " + str(error[0]) + "\n")
args["epocas"] = 200
print("\nValidación Simple, Población 50, 200 épocas")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
error = Clasificador.validacion(vs, tictac, gen, args=args)
print("\nError medio: " + str(error[0]) + "\n")
args["epocas"] = 100
args["pob_size"] = 150
print("\nValidación Simple, Población 150, 100 épocas")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
error = Clasificador.validacion(vs, tictac, gen, args=args)
print("\nError medio: " + str(error[0]) + "\n")
args["epocas"] = 200
print("\nValidación Simple, Población 150, 200 épocas")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
error = Clasificador.validacion(vs, tictac, gen, args=args)
print("\nError medio: " + str(error[0]) + "\n")
###################################################################################################################
# Análisis ROC
args = {
"epocas": 100,
"pob_size": 50,
"max": 3,
"prob_cruce": 0.5,
"prob_mutacion": 0.3,
"plot": False
}
print("50-100")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
vs.creaParticiones(tictac.datos)
particiones = vs.particiones
gen.entrenamiento(tictac.extraeDatos(particiones[0].indicesTrain),
tictac.nominalAtributos, tictac.diccionario, args)
datosTest = tictac.extraeDatos(particiones[0].indicesTest)
result = gen.clasifica(datosTest, tictac.nominalAtributos,
tictac.diccionario)
clase = datosTest[:, len(tictac.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, result[0])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
X_50_100 = fpr
Y_50_100 = tpr
args["pob_size"] = 150
print("150-100")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
vs.creaParticiones(tictac.datos)
particiones = vs.particiones
gen.entrenamiento(tictac.extraeDatos(particiones[0].indicesTrain),
tictac.nominalAtributos, tictac.diccionario, args)
datosTest = tictac.extraeDatos(particiones[0].indicesTest)
result = gen.clasifica(datosTest, tictac.nominalAtributos,
tictac.diccionario)
clase = datosTest[:, len(tictac.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, result[0])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
X_150_100 = fpr
Y_150_100 = tpr
args["pob_size"] = 50
args["epocas"] = 200
print("50-200")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
vs.creaParticiones(tictac.datos)
particiones = vs.particiones
gen.entrenamiento(tictac.extraeDatos(particiones[0].indicesTrain),
tictac.nominalAtributos, tictac.diccionario, args)
datosTest = tictac.extraeDatos(particiones[0].indicesTest)
result = gen.clasifica(datosTest, tictac.nominalAtributos,
tictac.diccionario)
clase = datosTest[:, len(tictac.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, result[0])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
X_50_200 = fpr
Y_50_200 = tpr
args["pob_size"] = 150
print("150-200")
gen = ClasificadorGenetico()
vs = ValidacionSimple()
vs.creaParticiones(tictac.datos)
particiones = vs.particiones
gen.entrenamiento(tictac.extraeDatos(particiones[0].indicesTrain),
tictac.nominalAtributos, tictac.diccionario, args)
datosTest = tictac.extraeDatos(particiones[0].indicesTest)
result = gen.clasifica(datosTest, tictac.nominalAtributos,
tictac.diccionario)
clase = datosTest[:, len(tictac.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, result[0])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
X_150_200 = fpr
Y_150_200 = tpr
print("NB")
nb = ClasificadorNaiveBayes()
vs = ValidacionSimple()
vs.creaParticiones(tictac.datos)
particiones = vs.particiones
nb.entrenamiento(tictac.extraeDatos(particiones[0].indicesTrain),
tictac.nominalAtributos, tictac.diccionario)
datosTest = tictac.extraeDatos(particiones[0].indicesTest)
result = nb.clasifica(datosTest, tictac.nominalAtributos,
tictac.diccionario)
clase = datosTest[:, len(tictac.nominalAtributos) - 1]
tp, tn, fp, fn = valores_roc(clase, result[0])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
X_nb = fpr
Y_nb = tpr
plt.figure()
lw = 2
plt.plot(X_50_100, Y_50_100, "ro", lw=lw, label="Gen 50-100")
plt.plot(X_150_100, Y_150_100, "go", lw=lw, label="Gen 150-100")
plt.plot(X_50_200, Y_50_200, "bo", lw=lw, label="Gen 50-200")
plt.plot(X_150_200, Y_150_200, "yo", lw=lw, label="Gen 150-200")
plt.plot([0, X_nb, 1], [0, Y_nb, 1], color="deeppink", lw=lw, label="NB")
plt.plot([0, 1], [0, 1], color='navy', lw=lw, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel("fpr")
plt.ylabel("tpr")
plt.title("ROC Tic-tac-toe")
plt.legend(loc="lower right")
plt.show()
nombre_fichero = raw_input()
print "Introduzca el porcentaje de particionado para el entrenamiento (para 1-1, introducir 1, para 2/3-1/3 introducir 0.66):"
porcentaje = raw_input()
while (float(porcentaje) <= 0.09 or float(porcentaje) > 1):
print "Porcentaje de particionado invalido."
print "Introduzca de nuevo el porcentaje de particionado para el entrenamiento (para 1-1, introducir 1, para 2/3-1/3 introducir 0.66):"
porcentaje = raw_input()
print ""
print "Generando salida del Perceptron ..."
print ""
dat = Datos(nombre_fichero, True)
val = ValidacionSimple(float(porcentaje))
clas1 = ClasificadorPerceptron()
errores1 = clas1.validacion(val, dat, clas1)
print "El error en la particion de test en el Perceptron es: "
print errores1[0]
print ""
print ""
print "Generando salida del Adaline ..."
print ""
clas2 = ClasificadorAdaline()
errores2 = clas2.validacion(val, dat, clas2)