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 clustering(self, dist):
iteracion = 1
centroides = self.inicializarCentroides()
print('Centroides calculados')
distancias = dis.Distancias(dist)
distancias.inicializarDist(centroides)
print('Distancias calculada')
while len(self.clust.keys()) != 1:
print(iteracion)
cl1, cl2, dist = distancias.minimaDist()
vector1 = self.clust[cl1]
vector2 = self.clust[cl2]
del self.clust[cl2]
del centroides[cl2]
self.clust[cl1] = vector1 + vector2
centroides[cl1] = ut.calcularCentro(self.clust[cl1], self.vect)
distancias.actualizarDist(centroides, cl1, cl2)
self.dist[dist] = copy(self.clust)
self.iter[iteracion] = copy(self.clust)
self.guardarIteracion(iteracion, dist, self.clust)
iteracion += 1
ut.guardar('resultados\dist.txt', self.dist)
ut.guardar('resultados\iter.txt', self.iter)
def generar_vocab_npalabras(self, docs, listaVocab):
"""
Dados los documentos y un path se genera los tf-idf de todas las palabras que se incluyen en el articulo, titulo y cuerpo
Pre: Los documentos y el path para guardar todos los tokens totales (no se van a usar todos)
Post: Se guardan todos los tokens y se devuelve los pesos de cada token de cada instancia
"""
palabras_dicc = dict([])
for i, doc in enumerate(docs):
palabras_dicc[i] = ' '.join(doc.palabras.titulo + doc.palabras.cuerpo)
listaVocab.update(palabras_dicc)
util.guardar(os.getcwd()+"/preproceso/todas_las_palabras.txt" ,listaVocab)
pesos = self.tfidf.fit_transform(listaVocab.values())
palabras = self.tfidf.get_feature_names()
print("Espacio vectorial analizado y valores tf_idf calculados")
return palabras, pesos
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 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 clustering(self, dist):
iteracion = 1
"Calculamos los centroides"
centroides = self.inicializarCentroides()
print('Centroides calculados')
"Inicializamos las distancias"
distancias = dis.Distancias(len(self.vect), dist)
distancias.inicializarDist(centroides)
print('Distancias calculada')
while len(self.clust) != 1:
print(iteracion)
cl1, cl2, dist = distancias.minimaDist()
"Recogemos ambos clusters y actualizamos"
vector1 = self.clust[cl1]
vector2 = self.clust[cl2]
self.clust[cl1] = vector1 + vector2
centroides[cl1] = ut.calcularCentro(self.clust[cl1], self.vect)
distancias.actualizarDist(centroides, cl1, cl2)
del self.clust[cl2]
del centroides[cl2]
"Guardamos las nuevas iteraciones"
self.dist[dist] = copy(self.clust)
self.iter[iteracion] = copy(self.clust)
self.guardarIteracion(iteracion, dist, self.clust)
iteracion += 1
"Guardamos las estructuras de datos para utilizarlas mas tarde"
ut.guardar(os.getcwd() + "/resultados/dist.txt", self.dist)
ut.guardar(os.getcwd() + "/resultados/iter.txt", self.iter)
def preprocesar_train(directorio_ruta):
"""
Dada una ruta de datos se genera el dataset de las instancias nuevas
Pre: El directorio de los datos
Post: La lista de instancias con tuplas de pesos tf-idf de cada instancia
"""
#directorio = 'datos'
print('\nGenerando los vectores de las instancias')
train, test = shuffle_split(directorio_ruta)
lista = list(crearListaTemasTotales(train) | crearListaTemasTotales(test))
print("Hay " + str(len(lista)) + " temas totales en el conjunto de datos analizados")
for doc in train:
doc.asignarTemaNumerico(lista)
util.guardar(os.getcwd()+"/preproceso/lista_temas.txt", lista)
tfidf = Tf_Idf()
tfidf.generar_vector_tupla_pesos(train)
selector = SelectorAtributos(tfidf.vector, train, "train")
util.guardar(os.getcwd()+"/preproceso/lista_articulos_train.txt", train)
util.guardar(os.getcwd()+"/preproceso/lista_articulos_test.txt", test)
util.guardar(os.getcwd()+"/preproceso/train_tfidf.txt", selector.espacio_vectorial)
util.guardar(os.getcwd()+"/preproceso/raw_tfidf", tfidf)
print('Preproceso completado!')
return selector.espacio_vectorial, train
def elegirAtributos(self, pesos, name):
"""
genera un vector reducido de atributos
Pre: los pesos de tf_idf.vector
Post: una lista ordenada de el par de atributos (atributo y peso)
"""
atributos = set()
tfidf_score = dict([])
for articulo, documento_scores in pesos.items():
mas = dict(sorted(documento_scores.items(), key=itemgetter(1), reverse=True)[:5])
for palabra, score in mas.items():
if score > 0.0:
atributos.add(palabra)
tfidf_score[palabra] = score
# reducir el vetor hasta un 10%
longitud = int(len(atributos) / 10)
atributo_pareado = dict(sorted(tfidf_score.items(), key=itemgetter(1), reverse=True)[:longitud])
#self.atributos.append(sorted(atributos))
#print(sorted(atributos))
self.atributos.append(sorted(atributo_pareado))
util.guardar(os.getcwd()+"/preproceso/vocabulario_" + name + ".txt" ,self.atributos)
#self.atributos.append(sorted(atributo_pareado))
print("Se ha reducido el espacio vectorial en un 90%")
def preprocesar(directorio_ruta):
"""
Dada una ruta de datos se genera el dataset de las instancias nuevas
Pre: El directorio de los datos
Post: La lista de instancias con tuplas de pesos tf-idf de cada instancia
"""
#directorio = 'datos'
print('\nGenerando los vectores de las instancias')
documentos = escanear_docs(directorio_ruta)
random.shuffle(documentos)
tfidf = Tf_Idf()
tfidf.generar_vocab_npalabras(documentos)
util.guardar(os.getcwd() + "/preproceso/full_lista_articulos.txt",
documentos)
util.guardar(os.getcwd() + "/preproceso/full_tfidf.txt", tfidf.vPesos)
util.guardar(os.getcwd() + "/preproceso/raw_full_tfidf", tfidf)
print('Preproceso completado!')
return tfidf.vPesos, documentos
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")
