def insertarDatos(self, carga):
bd = BaseDatos.baseDatosClass()
con = bd.conexion()
bdAlertas = bd.conexionAlertas(con)
bdEstadisticas = bd.conexionEstadisticas(con)
c = Clasificador.ClasificadorClass()
tweet = carga["text"]
lista = []
lista.append(tweet)
categoria = c.clasificarTweets(tweet)
print ("La categoria es : " , categoria);
if(categoria != "Nada"):
fecha= time.strftime('%Y-%m-%d %H:%M:%S', time.strptime(carga['created_at'],'%a %b %d %H:%M:%S +0000 %Y'))
datetime_object = datetime.strptime(fecha, '%Y-%m-%d %H:%M:%S');
resultado = datetime_object + timedelta(hours=2)
mes = time.strftime('%m', time.strptime(carga['created_at'],'%a %b %d %H:%M:%S +0000 %Y'))
mes = int(mes)
nombreUsuario = "@"+carga["user"]["screen_name"]
zona = c.clasificadorZona(lista)
print(zona)
bd.insertarEstadisticas(bdEstadisticas,zona,categoria,mes)
bd.insertarAlerta(bdAlertas,tweet,resultado,None,zona,categoria,nombreUsuario)
del dataset
except NameError:
pass
#####################################################################################################
dataset = Datos(args.ruta)
#####################################################################################################
if args.plot:
if args.KNN:
if args.norm:
titulo = (args.ruta.split('/')[-1]
) + (": KNN con k= %d y normalizando") % args.k[0]
else:
titulo = (args.ruta.split('/')[-1]
) + (": KNN con k= %d sin normalizar") % args.k[0]
clasificador = Clasificador.ClasificadorVecinosProximos()
clasificador.k_vecinos = args.k[0]
clasificador.normalizacion = args.norm
elif args.regLog:
titulo = (args.ruta.split('/')[-1]) + (
": Regresion Logistica con %d") % args.epocas + (" epocas")
clasificador = Clasificador.ClasificadorRegresionLogistica()
clasificador.epocas = args.epocas
clasificador.cte_aprendizaje = args.aprendizaje
else:
sys.exit(
"Debes especifiar el modelo (KNN o regLog) y sus correspondientes argumentos"
)
estrategia = EstrategiaParticionado.ValidacionSimple()
error = clasificador.validacion(estrategia, dataset, clasificador)
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))
sys.path.append('../')
from Clasificador import Clasificador
from BaseDatos import BaseDatos
import ParseoFecha
from datetime import datetime, timedelta
page = requests.get("https://www.madridiario.es/indice-distritos/")
#print(page.status_code)
soup = BeautifulSoup(page.content, 'html.parser')
#print(soup.prettify()) #muestra el contenido HTML mejor presentado
entradas = soup.find_all('li')
#Instancia a la clase Clasificador
clasificador = Clasificador.ClasificadorClass()
bd = BaseDatos.baseDatosClass()
con = bd.conexion()
bdAlertas = bd.conexionAlertas(con)
bdEstadisticas = bd.conexionEstadisticas(con)
f = ParseoFecha.ParseoFechaClass()
for i, entrada in enumerate(entradas):
link = entrada.find('a').get('href') # con esto obtenemos el link a todos los distritos
distrito = entrada.find('a').get_text()
print(distrito)
page2 = requests.get(link)
soup2 = BeautifulSoup(page2.content, 'html.parser')
distritos = soup2.find_all(class_="fueraNoticia")
X, y = make_moons(n_samples=100,
shuffle=True,
noise=0.5,
random_state=None)
datostrain = np.column_stack((X, y))
Xt, yt = make_moons(n_samples=200,
shuffle=True,
noise=0.5,
random_state=None)
datostest = np.column_stack((Xt, yt))
cambiaClase = Clasificador()
score_final_tree = 0
iteracion = 1
print("Iteracion: " + str(iteracion))
clfTree, datos_cambiados = cambiaClase.entrenamiento(datostrain, 100, 0.5)
score_final_tree += clfTree.score(datostest)
clasificaciones = clfTree.predict(datostest)
print("Arbol de decision: " + str(score_final_tree))
print("Clasificaciones: " + str(clasificaciones))
############################## 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)
# Probamos con 75 porciento y 10 iteraciones (Validacion Simple)
validacion_simple_ger = ValidacionSimple(75,10)
aux_simple_ger = validacion_simple_ger.creaParticiones(datos_ger)
# Probamos con 10 k-iteraciones
validacion_cruzada_ger = ValidacionCruzada(10)
aux_cruzada_ger = validacion_cruzada_ger.creaParticiones(datos_ger)
try:
'''
En este Main se prueba la clasificacion de ruido con respecto a la clase original.
Que obtengamos 0 a la hora de predecir significa que es ruido.
El score se mide suponiendo que el dataset no tiene nada de ruido.
'''
dataset = Datos('Datasets/example1.data')
num_particiones = 10
num_arboles = 1
#estrategia = EstrategiaParticionado.ValidacionCruzada(num_particiones)
estrategia = EstrategiaParticionado.ValidacionSimple(1, 80)
cambiaClase = Clasificador()
particiones = estrategia.creaParticiones(dataset)
score_final_tree = 0
iteracion = 1
print("Iteracion: " + str(iteracion))
datostrain = dataset.extraeDatos(particiones[0].getTrain())
datostest = dataset.extraeDatos(particiones[0].getTest())
clfTree, datos_cambiados = cambiaClase.entrenamiento(
datostrain, num_arboles, 0.5)
from Clasificador import Clasificador
from sklearn import tree
import EstrategiaParticionado
import numpy as np
import random
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt
try:
'''
En este Main se prueba la clasificacion de ruido con respecto a la clase original.
Que obtengamos 0 a la hora de predecir significa que es ruido.
El score se mide suponiendo que el dataset no tiene nada de ruido.
'''
cambiaClase = Clasificador()
Xt, yt = make_moons(n_samples=20000,
shuffle=True,
noise=0.5,
random_state=None)
datostest = np.column_stack((Xt, yt))
iteracion = 1
num_trees = 100
tasas_error = [0. for x in range(num_trees)]
for i in range(100):
print "Iteracion " + str(i + 1) + "/100"
X, y = make_moons(n_samples=500,
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()
def main():
diabetes = Datos("pima-indians-diabetes.data")
wdbc = Datos("wdbc.data")
print("Diabetes:\n")
print("nominalAtributos:")
print(diabetes.nominalAtributos)
print("\nDiccionario:")
print(diabetes.diccionario)
print("\nDatos:")
print(diabetes.datos)
print("\nValidacion Cruzada NB")
print("\nValidando con clasificador propio:")
nb = ClasificadorNaiveBayes()
vc = ValidacionCruzada()
error = Clasificador.validacion(vc, diabetes, nb)
print("\n Error medio:")
print("sin Laplace: " + str(error[0]))
print("con Laplace: " + str(error[1]))
#######################################################################################################################
print("\nValidacion Cruzada K-NN")
print("\nValidando con clasificador propio:")
knn = ClasificadorVecinosProximos()
vc = ValidacionCruzada()
error = Clasificador.validacion(vc, diabetes, knn)
print("\nError medio k=1")
print("euclidea: " + str(error[0]))
print("manhattan: " + str(error[1]))
print("mahalanobis: " + str(error[2]))
print("\nError medio k=5")
print("euclidea: " + str(error[3]))
print("manhattan: " + str(error[4]))
print("mahalanobis: " + str(error[5]))
print("\nError medio k=11")
print("euclidea: " + str(error[6]))
print("manhattan: " + str(error[7]))
print("mahalanobis: " + str(error[8]))
print("\nError medio k=21")
print("euclidea: " + str(error[9]))
print("manhattan: " + str(error[10]))
print("mahalanobis: " + str(error[11]))
#######################################################################################################################
print("\nValidacion Cruzada Regresión Logística")
print("\nValidando con clasificador propio:")
reg = ClasificadorRegresionLogistica()
vc = ValidacionCruzada()
error = Clasificador.validacion(vc, diabetes, reg)
print("\n Error medio: " + str(error))
#######################################################################################################################
print("\n\nWdbc:\n")
print("nominalAtributos:")
print(wdbc.nominalAtributos)
print("\nDiccionario:")
print(wdbc.diccionario)
print("\nDatos:")
print(wdbc.datos)
print("\n\nWdbc:")
print("\nValidacion Cruzada NB")
print("\nValidando con clasificador propio:")
nb = ClasificadorNaiveBayes()
vc = ValidacionCruzada()
error = Clasificador.validacion(vc, wdbc, nb)
print("\n Error medio:")
print("sin Laplace: " + str(error[0]))
print("con Laplace: " + str(error[1]))
#######################################################################################################################
print("\nValidacion Cruzada K-NN")
print("\nValidando con clasificador propio:")
knn = ClasificadorVecinosProximos()
vc = ValidacionCruzada()
error = Clasificador.validacion(vc, wdbc, knn)
print("\nError medio k=1")
print("euclidea: " + str(error[0]))
print("manhattan: " + str(error[1]))
print("mahalanobis: " + str(error[2]))
print("\nError medio k=5")
print("euclidea: " + str(error[3]))
print("manhattan: " + str(error[4]))
print("mahalanobis: " + str(error[5]))
print("\nError medio k=11")
print("euclidea: " + str(error[6]))
print("manhattan: " + str(error[7]))
print("mahalanobis: " + str(error[8]))
print("\nError medio k=21")
print("euclidea: " + str(error[9]))
print("manhattan: " + str(error[10]))
print("mahalanobis: " + str(error[11]))
#######################################################################################################################
print("\nValidacion Cruzada Regresión Logística")
print("\nValidando con clasificador propio:")
reg = ClasificadorRegresionLogistica()
vc = ValidacionCruzada()
error = Clasificador.validacion(vc, wdbc, reg)
print("\nError medio: " + str(error))
########################################################################################################################
########################################################################################################################
# SKLEARN
X = diabetes.datos[:, :-1]
Y = diabetes.datos[:, -1]
x = np.transpose(X)
X2 = wdbc.datos[:, :-1]
Y2 = wdbc.datos[:, -1]
x2 = np.transpose(X2)
print("\n\nDiabetes:")
####################################################################################################################
print("************Knn SKLEARN************\n")
print("\nK = 1\n")
clf = KNeighborsClassifier(n_neighbors=1, p=2, metric='euclidean')
score = cross_val_score(clf, X, Y, cv=10, n_jobs=-1)
error_media_sk = 1 - score.mean()
error_std_sk = score.std()
print("Error medio sklearn euclidean: " + str(error_media_sk))
print("Desviación media del error sklearn euclidean: " + str(error_std_sk))
clfM = KNeighborsClassifier(n_neighbors=1, p=2, metric='manhattan')
scoreM = cross_val_score(clfM, X, Y, cv=10, n_jobs=-1)
error_media_skM = 1 - scoreM.mean()
error_std_skM = scoreM.std()
print("Error medio sklearn manhattan: " + str(error_media_skM))
print("Desviación media del error sklearn manhattan: " +
str(error_std_skM))
clfMahalan = KNeighborsClassifier(n_neighbors=1,
p=2,
metric='mahalanobis',
metric_params={'V': np.cov(x)})
scoreMahalan = cross_val_score(clfMahalan, X, Y, cv=10, n_jobs=-1)
error_media_skMahalan = 1 - scoreMahalan.mean()
error_std_skMahalan = scoreMahalan.std()
print("Error medio sklearn mahalanobis: " + str(error_media_skMahalan))
print("Desviación media del error sklearn mahalanobis: " +
str(error_std_skMahalan))
print("\nK = 3\n")
clf3 = KNeighborsClassifier(n_neighbors=3, p=2, metric='euclidean')
score3 = cross_val_score(clf3, X, Y, cv=10, n_jobs=-1)
error_media_sk3 = 1 - score3.mean()
error_std_sk3 = score3.std()
print("Error medio sklearn euclidean: " + str(error_media_sk3))
print("Desviación media del error sklearn euclidean: " +
str(error_std_sk3))
clf3M = KNeighborsClassifier(n_neighbors=3, p=2, metric='manhattan')
score3M = cross_val_score(clf3M, X, Y, cv=10, n_jobs=-1)
error_media_sk3M = 1 - score3M.mean()
error_std_sk3M = score3M.std()
print("Error medio sklearn manhattan: " + str(error_media_sk3M))
print("Desviación media del error sklearn manhattan: " +
str(error_std_sk3M))
clf3Mahalan = KNeighborsClassifier(n_neighbors=3,
p=2,
metric='mahalanobis',
metric_params={'V': np.cov(x)})
score3Mahalan = cross_val_score(clf3Mahalan, X, Y, cv=10, n_jobs=-1)
error_media_sk3Mahalan = 1 - score3Mahalan.mean()
error_std_sk3Mahalan = score3Mahalan.std()
print("Error medio sklearn mahalanobis: " + str(error_media_sk3Mahalan))
print("Desviación media del error sklearn mahalanobis: " +
str(error_std_sk3Mahalan))
print("\nK = 5\n")
clf5 = KNeighborsClassifier(n_neighbors=5, p=2, metric='euclidean')
score5 = cross_val_score(clf5, X, Y, cv=10, n_jobs=-1)
error_media_sk5 = 1 - score5.mean()
error_std_sk5 = score5.std()
print("Error medio sklearn euclidean: " + str(error_media_sk5))
print("Desviación media del error sklearn euclidean: " +
str(error_std_sk5))
clf5M = KNeighborsClassifier(n_neighbors=5, p=2, metric='manhattan')
score5M = cross_val_score(clf5M, X, Y, cv=10, n_jobs=-1)
error_media_sk5M = 1 - score5M.mean()
error_std_sk5M = score5M.std()
print("Error medio sklearn manhattan: " + str(error_media_sk5M))
print("Desviación media del error sklearn manhattan: " +
str(error_std_sk5M))
clf5Mahalan = KNeighborsClassifier(n_neighbors=5,
p=2,
metric='mahalanobis',
metric_params={'V': np.cov(x)})
score5Mahalan = cross_val_score(clf5Mahalan, X, Y, cv=10, n_jobs=-1)
error_media_sk5Mahalan = 1 - score5Mahalan.mean()
error_std_sk5Mahalan = score5Mahalan.std()
print("Error medio sklearn mahalanobis: " + str(error_media_sk5Mahalan))
print("Desviación media del error sklearn mahalanobis: " +
str(error_std_sk5Mahalan))
print("\nK = 11\n")
clf11 = KNeighborsClassifier(n_neighbors=11, p=2, metric='euclidean')
score11 = cross_val_score(clf11, X, Y, cv=10, n_jobs=-1)
error_media_sk11 = 1 - score11.mean()
error_std_sk11 = score11.std()
print("Error medio sklearn euclidean: " + str(error_media_sk11))
print("Desviación media del error sklearn euclidean: " +
str(error_std_sk11))
clf11M = KNeighborsClassifier(n_neighbors=11, p=2, metric='manhattan')
score11M = cross_val_score(clf11M, X, Y, cv=10, n_jobs=-1)
error_media_sk11M = 1 - score11M.mean()
error_std_sk11M = score11M.std()
print("Error medio sklearn manhattan: " + str(error_media_sk11M))
print("Desviación media del error sklearn manhattan: " +
str(error_std_sk11M))
clf11Mahalan = KNeighborsClassifier(n_neighbors=11,
p=2,
metric='mahalanobis',
metric_params={'V': np.cov(x)})
score11Mahalan = cross_val_score(clf11Mahalan, X, Y, cv=10, n_jobs=-1)
error_media_sk11Mahalan = 1 - score11Mahalan.mean()
error_std_sk11Mahalan = score11Mahalan.std()
print("Error medio sklearn mahalanobis: " + str(error_media_sk11Mahalan))
print("Desviación media del error sklearn mahalanobis: " +
str(error_std_sk11Mahalan))
print("\nK = 21\n")
clf21 = KNeighborsClassifier(n_neighbors=21, p=2, metric='euclidean')
score21 = cross_val_score(clf21, X, Y, cv=10, n_jobs=-1)
error_media_sk21 = 1 - score21.mean()
error_std_sk21 = score21.std()
print("Error medio sklearn euclidean: " + str(error_media_sk21))
print("Desviación media del error sklearn euclidean: " +
str(error_std_sk21))
clf21M = KNeighborsClassifier(n_neighbors=21, p=2, metric='manhattan')
score21M = cross_val_score(clf21M, X, Y, cv=10, n_jobs=-1)
error_media_sk21M = 1 - score21M.mean()
error_std_sk21M = score21M.std()
print("Error medio sklearn manhattan: " + str(error_media_sk21M))
print("Desviación media del error sklearn manhattan: " +
str(error_std_sk21M))
clf21Mahalan = KNeighborsClassifier(n_neighbors=21,
p=2,
metric='mahalanobis',
metric_params={'V': np.cov(x)})
score21Mahalan = cross_val_score(clf21Mahalan, X, Y, cv=10, n_jobs=-1)
error_media_sk21Mahalan = 1 - score21Mahalan.mean()
error_std_sk21Mahalan = score21Mahalan.std()
print("Error medio sklearn mahalanobis: " + str(error_media_sk21Mahalan))
print("Desviación media del error sklearn mahalanobis: " +
str(error_std_sk21Mahalan))
####################################################################################################################
print("\n*************** Regresión Logística ***************")
print("\nLogisticRegression")
clfRL = LogisticRegression(max_iter=10000, fit_intercept=1)
scoreRL = cross_val_score(clfRL, X, Y, cv=10, n_jobs=-1)
error_media_skRL = 1 - scoreRL.mean()
error_std_skRL = scoreRL.std()
print("Error medio LogisticRegression: " + str(error_media_skRL))
print("Desviación media del error LogisticRegression: " +
str(error_std_skRL))
print("\nSGDClassifier")
clfSGDC = SGDClassifier(max_iter=100, learning_rate='constant', eta0=1)
scoreSGDC = cross_val_score(clfSGDC, X, Y, cv=10, n_jobs=-1)
error_media_skSGDC = 1 - scoreSGDC.mean()
error_std_skSGDC = scoreSGDC.std()
print("Error medio SGDClassifier: " + str(error_media_skSGDC))
print("Desviación media del error SGDClassifier: " + str(error_std_skSGDC))
####################################################################################################################
print("Wdbc:\n")
print("nominalAtributos:")
print(wdbc.nominalAtributos)
print("\nDiccionario:")
print(wdbc.diccionario)
print("\nDatos:")
print(wdbc.datos)
####################################################################################################################
print("************Knn SKLEARN************\n")
print("\nK = 1\n")
clf = KNeighborsClassifier(n_neighbors=1, p=2, metric='euclidean')
score = cross_val_score(clf, X2, Y2, cv=10, n_jobs=-1)
error_media_sk = 1 - score.mean()
error_std_sk = score.std()
print("Error medio sklearn euclidean: " + str(error_media_sk))
print("Desviación media del error sklearn euclidean: " + str(error_std_sk))
clfM = KNeighborsClassifier(n_neighbors=1, p=2, metric='manhattan')
scoreM = cross_val_score(clfM, X2, Y2, cv=10, n_jobs=-1)
error_media_skM = 1 - scoreM.mean()
error_std_skM = scoreM.std()
print("Error medio sklearn manhattan: " + str(error_media_skM))
print("Desviación media del error sklearn manhattan: " +
str(error_std_skM))
clfMahalan = KNeighborsClassifier(n_neighbors=1,
p=2,
metric='mahalanobis',
metric_params={'V': np.cov(x2)})
scoreMahalan = cross_val_score(clfMahalan, X2, Y2, cv=10, n_jobs=-1)
error_media_skMahalan = 1 - scoreMahalan.mean()
error_std_skMahalan = scoreMahalan.std()
print("Error medio sklearn mahalanobis: " + str(error_media_skMahalan))
print("Desviación media del error sklearn mahalanobis: " +
str(error_std_skMahalan))
print("\nK = 3\n")
clf3 = KNeighborsClassifier(n_neighbors=3, p=2, metric='euclidean')
score3 = cross_val_score(clf3, X2, Y2, cv=10, n_jobs=-1)
error_media_sk3 = 1 - score3.mean()
error_std_sk3 = score3.std()
print("Error medio sklearn euclidean: " + str(error_media_sk3))
print("Desviación media del error sklearn euclidean: " +
str(error_std_sk3))
clf3M = KNeighborsClassifier(n_neighbors=3, p=2, metric='manhattan')
score3M = cross_val_score(clf3M, X2, Y2, cv=10, n_jobs=-1)
error_media_sk3M = 1 - score3M.mean()
error_std_sk3M = score3M.std()
print("Error medio sklearn manhattan: " + str(error_media_sk3M))
print("Desviación media del error sklearn manhattan: " +
str(error_std_sk3M))
clf3Mahalan = KNeighborsClassifier(n_neighbors=3,
p=2,
metric='mahalanobis',
metric_params={'V': np.cov(x2)})
score3Mahalan = cross_val_score(clf3Mahalan, X2, Y2, cv=10, n_jobs=-1)
error_media_sk3Mahalan = 1 - score3Mahalan.mean()
error_std_sk3Mahalan = score3Mahalan.std()
print("Error medio sklearn mahalanobis: " + str(error_media_sk3Mahalan))
print("Desviación media del error sklearn mahalanobis: " +
str(error_std_sk3Mahalan))
print("\nK = 5\n")
clf5 = KNeighborsClassifier(n_neighbors=5, p=2, metric='euclidean')
score5 = cross_val_score(clf5, X2, Y2, cv=10, n_jobs=-1)
error_media_sk5 = 1 - score5.mean()
error_std_sk5 = score5.std()
print("Error medio sklearn euclidean: " + str(error_media_sk5))
print("Desviación media del error sklearn euclidean: " +
str(error_std_sk5))
clf5M = KNeighborsClassifier(n_neighbors=5, p=2, metric='manhattan')
score5M = cross_val_score(clf5M, X2, Y2, cv=10, n_jobs=-1)
error_media_sk5M = 1 - score5M.mean()
error_std_sk5M = score5M.std()
print("Error medio sklearn manhattan: " + str(error_media_sk5M))
print("Desviación media del error sklearn manhattan: " +
str(error_std_sk5M))
clf5Mahalan = KNeighborsClassifier(n_neighbors=5,
p=2,
metric='mahalanobis',
metric_params={'V': np.cov(x2)})
score5Mahalan = cross_val_score(clf5Mahalan, X2, Y2, cv=10, n_jobs=-1)
error_media_sk5Mahalan = 1 - score5Mahalan.mean()
error_std_sk5Mahalan = score5Mahalan.std()
print("Error medio sklearn mahalanobis: " + str(error_media_sk5Mahalan))
print("Desviación media del error sklearn mahalanobis: " +
str(error_std_sk5Mahalan))
print("\nK = 11\n")
clf11 = KNeighborsClassifier(n_neighbors=11, p=2, metric='euclidean')
score11 = cross_val_score(clf11, X2, Y2, cv=10, n_jobs=-1)
error_media_sk11 = 1 - score11.mean()
error_std_sk11 = score11.std()
print("Error medio sklearn euclidean: " + str(error_media_sk11))
print("Desviación media del error sklearn euclidean: " +
str(error_std_sk11))
clf11M = KNeighborsClassifier(n_neighbors=11, p=2, metric='manhattan')
score11M = cross_val_score(clf11M, X2, Y2, cv=10, n_jobs=-1)
error_media_sk11M = 1 - score11M.mean()
error_std_sk11M = score11M.std()
print("Error medio sklearn manhattan: " + str(error_media_sk11M))
print("Desviación media del error sklearn manhattan: " +
str(error_std_sk11M))
clf11Mahalan = KNeighborsClassifier(n_neighbors=11,
p=2,
metric='mahalanobis',
metric_params={'V': np.cov(x2)})
score11Mahalan = cross_val_score(clf11Mahalan, X2, Y2, cv=10, n_jobs=-1)
error_media_sk11Mahalan = 1 - score11Mahalan.mean()
error_std_sk11Mahalan = score11Mahalan.std()
print("Error medio sklearn mahalanobis: " + str(error_media_sk11Mahalan))
print("Desviación media del error sklearn mahalanobis: " +
str(error_std_sk11Mahalan))
print("\nK = 21\n")
clf21 = KNeighborsClassifier(n_neighbors=21, p=2, metric='euclidean')
score21 = cross_val_score(clf21, X2, Y2, cv=10, n_jobs=-1)
error_media_sk21 = 1 - score21.mean()
error_std_sk21 = score21.std()
print("Error medio sklearn euclidean: " + str(error_media_sk21))
print("Desviación media del error sklearn euclidean: " +
str(error_std_sk21))
clf21M = KNeighborsClassifier(n_neighbors=21, p=2, metric='manhattan')
score21M = cross_val_score(clf21M, X2, Y2, cv=10, n_jobs=-1)
error_media_sk21M = 1 - score21M.mean()
error_std_sk21M = score21M.std()
print("Error medio sklearn manhattan: " + str(error_media_sk21M))
print("Desviación media del error sklearn manhattan: " +
str(error_std_sk21M))
clf21Mahalan = KNeighborsClassifier(n_neighbors=21,
p=2,
metric='mahalanobis',
metric_params={'V': np.cov(x2)})
score21Mahalan = cross_val_score(clf21Mahalan, X2, Y2, cv=10, n_jobs=-1)
error_media_sk21Mahalan = 1 - score21Mahalan.mean()
error_std_sk21Mahalan = score21Mahalan.std()
print("Error medio sklearn mahalanobis: " + str(error_media_sk21Mahalan))
print("Desviación media del error sklearn mahalanobis: " +
str(error_std_sk21Mahalan))
########################################################################################################################
print("\n*************** Regresión Logística ***************")
print("\nLogisticRegression")
clfRL = LogisticRegression(max_iter=10000, fit_intercept=1)
scoreRL = cross_val_score(clfRL, X2, Y2, cv=10, n_jobs=-1)
error_media_skRL = 1 - scoreRL.mean()
error_std_skRL = scoreRL.std()
print("Error medio LogisticRegression: " + str(error_media_skRL))
print("Desviación media del error LogisticRegression: " +
str(error_std_skRL))
print("\nSGDClassifier")
clfSGDC = SGDClassifier(max_iter=100, learning_rate='constant', eta0=1)
scoreSGDC = cross_val_score(clfSGDC, X2, Y2, cv=10, n_jobs=-1)
error_media_skSGDC = 1 - scoreSGDC.mean()
error_std_skSGDC = scoreSGDC.std()
print("Error medio SGDClassifier: " + str(error_media_skSGDC))
print("Desviación media del error SGDClassifier: " + str(error_std_skSGDC))
########################################################################################################################
########################################################################################################################
# Análisis ROC
diabetes = Datos("pima-indians-diabetes.data")
wdbc = Datos("wdbc.data")
euclid_1_x = [0, 0, 1]
euclid_1_y = [0, 0, 1]
euclid_5_x = [0, 0, 1]
euclid_5_y = [0, 0, 1]
euclid_11_x = [0, 0, 1]
euclid_11_y = [0, 0, 1]
euclid_21_x = [0, 0, 1]
euclid_21_y = [0, 0, 1]
manhatt_1_x = [0, 0, 1]
manhatt_1_y = [0, 0, 1]
manhatt_5_x = [0, 0, 1]
manhatt_5_y = [0, 0, 1]
manhatt_11_x = [0, 0, 1]
manhatt_11_y = [0, 0, 1]
manhatt_21_x = [0, 0, 1]
manhatt_21_y = [0, 0, 1]
mahalan_1_x = [0, 0, 1]
mahalan_1_y = [0, 0, 1]
mahalan_5_x = [0, 0, 1]
mahalan_5_y = [0, 0, 1]
mahalan_11_x = [0, 0, 1]
mahalan_11_y = [0, 0, 1]
mahalan_21_x = [0, 0, 1]
mahalan_21_y = [0, 0, 1]
# K-NN -> Diabetes
knn = ClasificadorVecinosProximos()
vc = ValidacionCruzada()
vc.creaParticiones(diabetes.datos)
particiones = vc.particiones
for particion in particiones:
knn.entrenamiento(diabetes.extraeDatos(particion.indicesTrain),
diabetes.nominalAtributos, diabetes.diccionario)
datosTest = diabetes.extraeDatos(particion.indicesTest)
result = knn.clasifica(datosTest, diabetes.nominalAtributos,
diabetes.diccionario)
clase = datosTest[:, len(diabetes.nominalAtributos) - 1]
for i in range(0, len(result)):
tp, tn, fp, fn = valores_roc(clase, result[i])
# i va de 0 a 1
# i = 0, 1, 2 => k = 1
# i = 3, 4, 5 => k = 5
# i = 6, 7, 8 => k = 11
# i = 9, 10, 11 => k = 21
# i = 0, 3, 6, 9 => Distancia Euclidea
# i = 1, 4, 7, 10 => Distancia de Manhattan
# i = 2, 5, 8, 11 => Distancia de Mahalanobis
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
if i == 0:
euclid_1_x[1] += fpr
euclid_1_y[1] += tpr
elif i == 1:
manhatt_1_x[1] += fpr
manhatt_1_y[1] += tpr
elif i == 2:
mahalan_1_x[1] += fpr
mahalan_1_y[1] += tpr
elif i == 3:
euclid_5_x[1] += fpr
euclid_5_y[1] += tpr
elif i == 4:
manhatt_5_x[1] += fpr
manhatt_5_y[1] += tpr
elif i == 5:
mahalan_5_x[1] += fpr
mahalan_5_y[1] += tpr
elif i == 6:
euclid_11_x[1] += fpr
euclid_11_y[1] += tpr
elif i == 7:
manhatt_11_x[1] += fpr
manhatt_11_y[1] += tpr
elif i == 8:
mahalan_11_x[1] += fpr
mahalan_11_y[1] += tpr
elif i == 9:
euclid_21_x[1] += fpr
euclid_21_y[1] += tpr
elif i == 10:
manhatt_21_x[1] += fpr
manhatt_21_y[1] += tpr
elif i == 11:
mahalan_21_x[1] += fpr
mahalan_21_y[1] += tpr
euclid_1_x[1] /= len(particiones)
euclid_1_y[1] /= len(particiones)
euclid_5_x[1] /= len(particiones)
euclid_5_y[1] /= len(particiones)
euclid_11_x[1] /= len(particiones)
euclid_11_y[1] /= len(particiones)
euclid_21_x[1] /= len(particiones)
euclid_21_y[1] /= len(particiones)
manhatt_1_x[1] /= len(particiones)
manhatt_1_y[1] /= len(particiones)
manhatt_5_x[1] /= len(particiones)
manhatt_5_y[1] /= len(particiones)
manhatt_11_x[1] /= len(particiones)
manhatt_11_y[1] /= len(particiones)
manhatt_21_x[1] /= len(particiones)
manhatt_21_y[1] /= len(particiones)
mahalan_1_x[1] /= len(particiones)
mahalan_1_y[1] /= len(particiones)
mahalan_5_x[1] /= len(particiones)
mahalan_5_y[1] /= len(particiones)
mahalan_11_x[1] /= len(particiones)
mahalan_11_y[1] /= len(particiones)
mahalan_21_x[1] /= len(particiones)
mahalan_21_y[1] /= len(particiones)
repr_grafica('Curva ROC Diabetes K-NN k=1', 'False Positive Rate',
'True Positive Rate', 3,
['euclid', 'manhattan', 'mahalanobis'],
['darkorange', 'darkgreen', 'deeppink'],
[euclid_1_x, manhatt_1_x, mahalan_1_x],
[euclid_1_y, manhatt_1_y, mahalan_1_y])
repr_grafica('Curva ROC Diabetes K-NN k=5', 'False Positive Rate',
'True Positive Rate', 3,
['euclid', 'manhattan', 'mahalanobis'],
['darkorange', 'darkgreen', 'deeppink'],
[euclid_5_x, manhatt_5_x, mahalan_5_x],
[euclid_5_y, manhatt_5_y, mahalan_5_y])
repr_grafica('Curva ROC Diabetes K-NN k=11', 'False Positive Rate',
'True Positive Rate', 3,
['euclid', 'manhattan', 'mahalanobis'],
['darkorange', 'darkgreen', 'deeppink'],
[euclid_11_x, manhatt_11_x, mahalan_11_x],
[euclid_11_y, manhatt_11_y, mahalan_11_y])
repr_grafica('Curva ROC Diabetes K-NN k=21', 'False Positive Rate',
'True Positive Rate', 3,
['euclid', 'manhattan', 'mahalanobis'],
['darkorange', 'darkgreen', 'deeppink'],
[euclid_21_x, manhatt_21_x, mahalan_21_x],
[euclid_21_y, manhatt_21_y, mahalan_21_y])
euclid_1_x = [0, 0, 1]
euclid_1_y = [0, 0, 1]
euclid_5_x = [0, 0, 1]
euclid_5_y = [0, 0, 1]
euclid_11_x = [0, 0, 1]
euclid_11_y = [0, 0, 1]
euclid_21_x = [0, 0, 1]
euclid_21_y = [0, 0, 1]
manhatt_1_x = [0, 0, 1]
manhatt_1_y = [0, 0, 1]
manhatt_5_x = [0, 0, 1]
manhatt_5_y = [0, 0, 1]
manhatt_11_x = [0, 0, 1]
manhatt_11_y = [0, 0, 1]
manhatt_21_x = [0, 0, 1]
manhatt_21_y = [0, 0, 1]
mahalan_1_x = [0, 0, 1]
mahalan_1_y = [0, 0, 1]
mahalan_5_x = [0, 0, 1]
mahalan_5_y = [0, 0, 1]
mahalan_11_x = [0, 0, 1]
mahalan_11_y = [0, 0, 1]
mahalan_21_x = [0, 0, 1]
mahalan_21_y = [0, 0, 1]
# K-NN -> WDBC
knn = ClasificadorVecinosProximos()
vc = ValidacionCruzada()
vc.creaParticiones(wdbc.datos)
particiones = vc.particiones
for particion in particiones:
knn.entrenamiento(wdbc.extraeDatos(particion.indicesTrain),
wdbc.nominalAtributos, wdbc.diccionario)
datosTest = wdbc.extraeDatos(particion.indicesTest)
result = knn.clasifica(datosTest, wdbc.nominalAtributos,
wdbc.diccionario)
clase = datosTest[:, len(wdbc.nominalAtributos) - 1]
for i in range(0, len(result)):
tp, tn, fp, fn = valores_roc(clase, result[i])
# i va de 0 a 1
# i = 0, 1, 2 => k = 1
# i = 3, 4, 5 => k = 5
# i = 6, 7, 8 => k = 11
# i = 9, 10, 11 => k = 21
# i = 0, 3, 6, 9 => Distancia Euclidea
# i = 1, 4, 7, 10 => Distancia de Manhattan
# i = 2, 5, 8, 11 => Distancia de Mahalanobis
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
if i == 0:
euclid_1_x[1] += fpr
euclid_1_y[1] += tpr
elif i == 1:
manhatt_1_x[1] += fpr
manhatt_1_y[1] += tpr
elif i == 2:
mahalan_1_x[1] += fpr
mahalan_1_y[1] += tpr
elif i == 3:
euclid_5_x[1] += fpr
euclid_5_y[1] += tpr
elif i == 4:
manhatt_5_x[1] += fpr
manhatt_5_y[1] += tpr
elif i == 5:
mahalan_5_x[1] += fpr
mahalan_5_y[1] += tpr
elif i == 6:
euclid_11_x[1] += fpr
euclid_11_y[1] += tpr
elif i == 7:
manhatt_11_x[1] += fpr
manhatt_11_y[1] += tpr
elif i == 8:
mahalan_11_x[1] += fpr
mahalan_11_y[1] += tpr
elif i == 9:
euclid_21_x[1] += fpr
euclid_21_y[1] += tpr
elif i == 10:
manhatt_21_x[1] += fpr
manhatt_21_y[1] += tpr
elif i == 11:
mahalan_21_x[1] += fpr
mahalan_21_y[1] += tpr
euclid_1_x[1] /= len(particiones)
euclid_1_y[1] /= len(particiones)
euclid_5_x[1] /= len(particiones)
euclid_5_y[1] /= len(particiones)
euclid_11_x[1] /= len(particiones)
euclid_11_y[1] /= len(particiones)
euclid_21_x[1] /= len(particiones)
euclid_21_y[1] /= len(particiones)
manhatt_1_x[1] /= len(particiones)
manhatt_1_y[1] /= len(particiones)
manhatt_5_x[1] /= len(particiones)
manhatt_5_y[1] /= len(particiones)
manhatt_11_x[1] /= len(particiones)
manhatt_11_y[1] /= len(particiones)
manhatt_21_x[1] /= len(particiones)
manhatt_21_y[1] /= len(particiones)
mahalan_1_x[1] /= len(particiones)
mahalan_1_y[1] /= len(particiones)
mahalan_5_x[1] /= len(particiones)
mahalan_5_y[1] /= len(particiones)
mahalan_11_x[1] /= len(particiones)
mahalan_11_y[1] /= len(particiones)
mahalan_21_x[1] /= len(particiones)
mahalan_21_y[1] /= len(particiones)
repr_grafica('Curva ROC WDBC K-NN k=1', 'False Positive Rate',
'True Positive Rate', 3,
['euclid', 'manhattan', 'mahalanobis'],
['darkorange', 'darkgreen', 'deeppink'],
[euclid_1_x, manhatt_1_x, mahalan_1_x],
[euclid_1_y, manhatt_1_y, mahalan_1_y])
repr_grafica('Curva ROC WDBC K-NN k=5', 'False Positive Rate',
'True Positive Rate', 3,
['euclid', 'manhattan', 'mahalanobis'],
['darkorange', 'darkgreen', 'deeppink'],
[euclid_5_x, manhatt_5_x, mahalan_5_x],
[euclid_5_y, manhatt_5_y, mahalan_5_y])
repr_grafica('Curva ROC WDBC K-NN k=11', 'False Positive Rate',
'True Positive Rate', 3,
['euclid', 'manhattan', 'mahalanobis'],
['darkorange', 'darkgreen', 'deeppink'],
[euclid_11_x, manhatt_11_x, mahalan_11_x],
[euclid_11_y, manhatt_11_y, mahalan_11_y])
repr_grafica('Curva ROC WDBC K-NN k=21', 'False Positive Rate',
'True Positive Rate', 3,
['euclid', 'manhattan', 'mahalanobis'],
['darkorange', 'darkgreen', 'deeppink'],
[euclid_21_x, manhatt_21_x, mahalan_21_x],
[euclid_21_y, manhatt_21_y, mahalan_21_y])
####################################################################################################################
x = [0, 0, 1]
y = [0, 0, 1]
# Regresión -> Diabetes
reg = ClasificadorRegresionLogistica()
vc = ValidacionCruzada()
vc.creaParticiones(diabetes.datos)
particiones = vc.particiones
for particion in particiones:
reg.entrenamiento(diabetes.extraeDatos(particion.indicesTrain),
diabetes.nominalAtributos, diabetes.diccionario)
datosTest = diabetes.extraeDatos(particion.indicesTest)
result = reg.clasifica(datosTest, diabetes.nominalAtributos,
diabetes.diccionario)
clase = datosTest[:, len(diabetes.nominalAtributos) - 1]
for i in range(0, len(result)):
tp, tn, fp, fn = valores_roc(clase, result[i])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
x[1] += fpr
y[1] += tpr
x[1] /= len(particiones)
y[1] /= len(particiones)
repr_grafica('Curva ROC Regresión Diabetes', 'False Positive Rate',
'True Positive Rate', 1, ['Log_reg'], ['darkorange'], [x],
[y])
x = [0, 0, 1]
y = [0, 0, 1]
# Regresión -> WDBC
reg = ClasificadorRegresionLogistica()
vc = ValidacionCruzada()
vc.creaParticiones(wdbc.datos)
particiones = vc.particiones
for particion in particiones:
reg.entrenamiento(wdbc.extraeDatos(particion.indicesTrain),
wdbc.nominalAtributos, wdbc.diccionario)
datosTest = wdbc.extraeDatos(particion.indicesTest)
result = reg.clasifica(datosTest, wdbc.nominalAtributos,
wdbc.diccionario)
clase = datosTest[:, len(wdbc.nominalAtributos) - 1]
for i in range(0, len(result)):
tp, tn, fp, fn = valores_roc(clase, result[i])
tpr = tp / (tp + fn)
fpr = fp / (fp + tn)
x[1] += fpr
y[1] += tpr
x[1] /= len(particiones)
y[1] /= len(particiones)
repr_grafica('Curva ROC Regresión WDBC', 'False Positive Rate',
'True Positive Rate', 1, ['Log_reg'], ['darkorange'], [x],
[y])
for j in range(0, len(y_test_aux[i])):
if y_test_aux[i][j] != preds_aux[i][j]:
fallos += 1
porcentaje = round(fallos / float(len(y_test_aux[i])) * 100, 2)
porcentaje_aux.append(porcentaje)
print(" El error con Validacion Cruzada es del %.2f" %
round(np.mean(porcentaje_aux), 2)) + "%" + (
" Con una desviacion de %.2f" %
round(np.std(porcentaje_aux), 2)) + "%"
else:
print " - Usando nuestra libreria"
print "----------------------------------------------------"
estrategia = EstrategiaParticionado.ValidacionSimple()
clasificador = Clasificador.ClasificadorNaiveBayes()
errores = clasificador.validacion(estrategia,
dataset,
clasificador,
laPlace=args.laPlace,
porcentajeTrain=args.porcentaje)
print(" El error con Validacion Simple es del %.2f" %
round(errores[0] * 100, 2)) + "%"
del estrategia
del clasificador
estrategia = EstrategiaParticionado.ValidacionCruzada()
clasificador = Clasificador.ClasificadorNaiveBayes()
errores = clasificador.validacion(estrategia,