def preprocesar_newInst(tfidf_path, train_path, newData_path, vocabulario_path, lista_temas_path):
"""
Dado el dataset y las nuevas instancias se obtiene un nuevo dataset y sus pesos correspondientes en tf-idf
Pre: Los pesos tf-idf anteriores, el path de los datos anteriores, los datos nuevos, el path del nuevo dataset y el paz de todos los temas
Post: Se genera otro dataset tf-idf con las nuevas instancias
"""
#directorio = 'testing'
print('\nGenerando los vectores de las instancias')
newData = escanear_docs(newData_path)
#tfidf = util.cargar(os.getcwd()+ tfidf_path)
n_new_inst = len(newData)
lista_temas = util.cargar(os.getcwd()+lista_temas_path)
nuevos_temas = crearListaTemasTotales(newData)
#lista = list(nuevos_temas & set(lista_temas))
lista = list(nuevos_temas | set(lista_temas)) # equivale a lista= set(lista_temas).symmetric_difference(nuevos_temas)
util.guardar(os.getcwd()+'/preproceso/new_lista_temas.txt', lista)
for doc in newData:
doc.asignarTemaNumerico(lista)
train = util.cargar(os.getcwd()+train_path)
n_docs = len(train)
documentos = train + newData
util.guardar(os.getcwd()+"/preproceso/new_lista_articulos.txt", documentos)
listaVocabulario = util.cargar(os.getcwd()+vocabulario_path)
tfidf = Tf_Idf()
tfidf.generar_vector_tupla_pesos(newData)
selector = SelectorAtributos(tfidf.vector,documentos,"newInst")
selector.crear_dataset_especifico(tfidf.vector, documentos, "test", vocabulario_path)
util.guardar(os.getcwd()+"/preproceso/new_tfidf.txt", selector.espacio_vectorial)
print('Preproceso completado!')
return selector.espacio_vectorial, n_docs, n_new_inst
def preprocesar_test(tfidf_path, train_path, test_path, vocabulario_path, lista_temas_path):
"""
Dado el dataset y las nuevas instancias se obtiene un nuevo dataset y sus pesos correspondientes en tf-idf
Pre: Los pesos tf-idf anteriores, el path de los datos anteriores, los datos nuevos, el path del nuevo dataset y el paz de todos los temas
Post: Se genera otro dataset tf-idf con las nuevas instancias
"""
print("generar test tfidf")
test = util.cargar(os.getcwd()+ test_path)
tfidf = util.cargar(os.getcwd()+ tfidf_path)
tfidf.generar_vector_tupla_pesos(test)
selector_test = SelectorAtributos(tfidf.vector, test, "test")
selector_test.crear_dataset_especifico(tfidf.vector, test, "test", vocabulario_path)
util.guardar(os.getcwd()+"/preproceso/test_tfidf.txt", selector_test.espacio_vectorial)
print('\nGenerando los vectores de las instancias')
n_docs = len(tfidf.vector)
n_new_inst = len(test)
lista = list(crearListaTemasTotales(test) | set(util.cargar(os.getcwd()+lista_temas_path)))
util.guardar(os.getcwd()+'/preproceso/all_lista_temas', lista)
for doc in test:
doc.asignarTemaNumerico(lista)
"""
train = util.cargar(os.getcwd()+train_path)
documentos = train + test
util.guardar(os.getcwd()+"/preproceso/all_lista_articulos.txt", documentos)
listaVocabulario = util.cargar(os.getcwd()+vocabulario_path)
tfidf = tfidf.generar_vector_tupla_pesos_newInst(test, listaVocabulario)
selector = SelectorAtributos(tfidf.vector,documentos,"allInst")
util.guardar(os.getcwd()+"/preproceso/all_tfidf.txt", selector.espacio_vectorial)
"""
print('Preproceso completado!')
return selector_test.espacio_vectorial, n_docs, n_new_inst
def agruparInstanciasPorCluster(
path, instancias, numClus, instsAClasif, vectoresTest,
datosTest): #instAClasificar debera ser posicion o id
#vectoresTest = ut.cargar('/preproceso/new_tfidf')
#datosTest=ut.cargar('/preproceso/new_lista_articulos')
centroides = clustersIteracion(path, instancias, numClus)
agrupacion = []
cAct = 0
c = 0
"Indice centroide"
for inst in instsAClasif: #Recorrer instancias a clasificar
vecInst = vectoresTest[inst] #Coger el vector de la instancia TODO
mindist = 999999
c = 0
for cent in centroides: #Por cada centroide...
distancia = ut.calcularDistancia(
cent, vecInst,
1) #Buscar menor distancia manhattan centroide e instancia
if distancia < mindist:
mindist = distancia
centAct = cent
cAct = c #Indice del centroide/cluster dentro de la lista de centroides/clusters
c += 1
iteraciones = ut.cargar(os.getcwd() + path)
clusters = iteraciones[len(instancias) - numClus]
"Sabiendo la posicion se que cluster llevarme"
tema = temaMasComunEnInstancia(clusters[cAct], vecInst)
"Pasar instancias del cluster del cent, el id y vector de instAClasif"
temaReal = datosTest[inst].tema_numerico
agrupacion.append(
(inst, cent, tema,
temaReal)) #Instancia, centroide, tema agrupado, tema real
return agrupacion
def preprocesar_test(tfidf_path, train_path, test_path, vocabulario_path,
lista_temas_path):
"""
Dado el dataset y las nuevas instancias se obtiene un nuevo dataset y sus pesos correspondientes en tf-idf
Pre: Los pesos tf-idf anteriores, el path de los datos anteriores, los datos nuevos, el path del nuevo dataset y el paz de todos los temas
Post: Se genera otro dataset tf-idf con las nuevas instancias
"""
print("generar test tfidf")
test = util.cargar(os.getcwd() + test_path)
tfidf = util.cargar(os.getcwd() + tfidf_path)
print('\nGenerando los vectores de las instancias')
tfidf.generar_vocab_npalabras(test)
util.guardar(os.getcwd() + "/preproceso/test_tfidf.txt", tfidf.vPesos)
util.guardar(os.getcwd() + "/preproceso/raw_tfidf_test", tfidf)
print('Preproceso completado!')
return tfidf.vPesos, tfidf
def temaMasComunEnInstancia(
instCluster,
vecInst): #instCluster son posiciones, instancia es vector
"Recorrer instancias de cluster, coger las 10 mas cercanas a la instancia daba y devolver el maximo de los temas"
i = 1
temas = []
vectoresTrain = ut.cargar(os.getcwd() + '/preproceso/train_tfidf.txt')
datosTrain = ut.cargar(os.getcwd() +
'/preproceso/lista_articulos_train.txt')
listaTemas = ut.cargar(os.getcwd() + '/preproceso/new_lista_temas.txt')
j = 0
while j < len(listaTemas):
temas.append([j, 0]) #(TemaNumerico,Contador)
j = j + 1
instancias = [] #Lista de 10 instancias mas cercanas a la instancia test
distancias = [
] #Lista de distancias de instancias cluster a instancia test
for instCl in instCluster: #Instancias del cluster
vecInstCl = vectoresTrain[instCl]
distancias.append([
instCl, ut.calcularDistancia(vecInstCl, vecInst, 2)
]) #Coger la menor (Instancia cluster, distancia)
while i <= 10:
actual = min(
distancias, key=lambda t: t[1]
) #Devuelve la tupla con la instancia del cluster y la distancia minima a la distancia a clasificar.
distancias.remove(actual)
instancias.append(actual[0])
i += 1
"Buscar tema mayor entre las 10 instancias y ese sera el de la instancia a clasificar."
for posInst in instancias:
indTema = datosTrain[posInst].tema_numerico
t = 0
while t < len(listaTemas):
if t in indTema:
temas[t][1] += 1
t += 1
tema = max(
temas,
key=lambda t: t[1]) #Devuelve el tema que mas veces ha aparecido
#print(tema)
return tema[0]
def clustersIteracion(path, instancias, numclus):
iteraciones = ut.cargar(path)
clusters = iteraciones[len(instancias) - numclus]
print(len(clusters.keys()))
centroides = {}
for each in clusters.keys():
centroide = ut.calcularCentro(clusters[each], instancias)
centroides[each] = centroide
return centroides
def clustersIteracion(path, instancias, numclus):
iteraciones = ut.cargar(os.getcwd() + path)
clusters = iteraciones[len(instancias) - numclus]
centroides = ut.generarLista(len(clusters))
i = 0
while i < len(clusters):
centroide = ut.calcularCentro(clusters[i], instancias)
centroides[i] = centroide
i += 1
return centroides
def clusterDist(path, instancias, dist):
distancias = ut.cargar(path)
nivel = 0
for each in distancias.keys():
if each <= dist and each > nivel: nivel = each
clusters = distancias[nivel]
lista = ut.generarLista(len(instancias))
asig = ut.listaClusters(instancias, clusters, lista)
i = 0
while i < len(instancias):
guardarAsig(instancias[i], asig[i])
i += 1
def evaluar(self, path, instancias):
res = ut.cargar(path)
labels = ut.generarLista(len(instancias))
i = 0
parar = False
scoreMax = 0
hasta = len(res.keys()) * 0.9
for each in res.keys():
if i != 0 and i % 10 == 0 and i <= hasta and not parar:
agrup = res[each]
labels = ut.listaClusters(instancias, agrup, labels)
score = self.daviesBouldin(instancias, labels)
self.guardarScore(len(agrup.keys()), score)
if score > scoreMax: scoreMax = score
elif score < scoreMax:
parar = True
print(score)
i += 1
def crear_dataset_especifico(self,pesos,documentos, name, path_vocabulario):
"""
Dado la tabla de pesos, datos a analizar y atributos seleccionados, se crea una lista de tuplas para el calculo de distancias para generar un cluster
Pre: La tabla de pesos, los docmumentos a entrenar y los atributos seleccionados
Post: Se crea un dataset para el calculo de distancias y creacion de cluster
"""
#cambiar a vector de tuplas
self.atributos = util.cargar(os.getcwd()+path_vocabulario)
self.espacio_vectorial = []
for atributos_doc in self.atributos:
for i, documento in enumerate(documentos):
doc = list()
for atributo in atributos_doc:
try:
doc.append(pesos[i][atributo])
except KeyError as e:
doc.append(0.0)
self.espacio_vectorial.append(tuple(doc))
print("\nLista de tuplas de vectores " + name+ "_tf-idf generada")
print("Se han procesado " + str(len(self.espacio_vectorial)) + " instancias")
def runClusteringPruebas(argumentos):
import __main__
comienzo = time.time()
print('\n')
##########################################################################################
if not argumentos.all:
print('-----------Ejecucion completa-----------')
argumentos.skip_preproceso = argumentos.skip_jerarquico = argumentos.skip_kmeans = argumentos.skip_reglas = False
##########################################################################################
if not argumentos.skip_preproceso:
print('1: Preprocessing')
tfidf_vecs, documentos = preproceso.preprocesar(argumentos.preproceso)
print('Ha tardado en preprocesar ', calc_tiempo_trans(comienzo),
'segundos!')
##########################################################################################
if not argumentos.skip_jerarquico:
print('2: Cluster aglomerativo')
vector_dataset = util.cargar(os.getcwd() + argumentos.vector_tupla)
documentos = util.cargar(os.getcwd() + argumentos.backup_datos)
print('Se ha cargado los vectores tf-idf, del directorio: ' +
str(len(documentos)))
cluster = AgglomerativeClustering(n_clusters=3,
affinity='euclidean',
linkage='ward')
miCluster = cluster.fit_predict(vector_dataset.toarray())
etiquetas = cluster.labels_
print('Ha tardado en hacer el cluster jerarquico',
calc_tiempo_trans(comienzo), ' segundos!')
miEtiquetaElegida = util.etiquetaClusterTema(documentos, etiquetas)
print('Ha tardado en escoger un label para el cluster ',
calc_tiempo_trans(comienzo), ' segundos!')
file2csv.guardar_csv(argumentos.path_jerarquico, documentos, etiquetas,
miEtiquetaElegida)
print('Ha tardado en guardar en csv ', calc_tiempo_trans(comienzo),
' segundos!')
plt.figure(figsize=(10, 7))
plt.scatter(vector_dataset.toarray()[:, 0],
vector_dataset.toarray()[:, 1],
c=cluster.labels_,
cmap='rainbow')
plt.show()
print('Guardando en csv')
##########################################################################################
if not argumentos.skip_kmeans:
print('3: Cluster k-means')
vector_dataset = util.cargar(os.getcwd() + argumentos.vector_tupla)
docs = util.cargar(os.getcwd() + argumentos.backup_datos)
print("Se han cargado: " + str(len(docs)) + " instancias")
miCluster = KMeans(n_clusters=3)
miCluster.fit_predict(vector_dataset)
etiquetas = miCluster.labels_
print('Ha tardado en hacer el cluster k-means ',
calc_tiempo_trans(comienzo), ' segundos!')
miEtiquetaElegida = util.etiquetaClusterTema(docs, etiquetas)
print('Ha tardado en escoger un label para el cluster ',
calc_tiempo_trans(comienzo), ' segundos!')
file2csv.guardar_csv(argumentos.path_kmeans, docs, etiquetas,
miEtiquetaElegida)
print('Ha tardado en guardar en csv ', calc_tiempo_trans(comienzo),
' segundos!')
plt.figure(figsize=(10, 7))
plt.scatter(vector_dataset.toarray()[:, 0],
vector_dataset.toarray()[:, 1],
c=miCluster.labels_,
cmap='rainbow')
plt.show()
print('Ha tardado el cluster k-means', calc_tiempo_trans(comienzo),
' segundos!')
print('Guardando en csv')
##########################################################################################
if not argumentos.skip_reglas:
print('4: Reglas')
vector_dataset = util.cargar(os.getcwd() + argumentos.vector_tupla)
docs = util.cargar(os.getcwd() + argumentos.backup_datos)
res = asociacion.reglasApriori(argumentos.path_jerarquico)
util.guardar(os.getcwd() + "reglas", res)
asociacion.print_bonito(res)
asociacion.out_txt_reglas(res)
##########################################################################################
if not argumentos.all:
if sorted(cluster.labels_) == sorted(miCluster.labels_):
print("El cluster jerarquico y k-means han sido iguales")
print('\nFin del programa: ', calc_tiempo_trans(comienzo), 'segundos!')
print("Gracias por utilizar nuestro programa\n")
labels = ut.listaClusters(instancias, agrup, labels)
score = self.daviesBouldin(instancias, labels)
self.guardarScore(len(agrup.keys()), score)
if score > scoreMax: scoreMax = score
elif score < scoreMax:
parar = True
print(score)
i += 1
def daviesBouldin(self, inst, labels):
score = davies_bouldin_score(inst, labels)
return score
def calinskiHarabasz(self, inst, labels):
score = calinski_harabasz_score(inst, labels)
return score
def guardarScore(self, num, score):
string = ' Agrupaciones: {} '.format(num)
string += 'Score: {}'.format(round(score, 4))
string += '\n'
with open('resultados\score.txt', "a") as res:
res.write(string)
res.close()
clust = ut.cargar('resultados\datosAL.txt')
ev = Evaluador()
ev.evaluar('resultados\dist.txt', clust)