<jupyter_start><jupyter_text>Se debe agregar la carpeta a analizar en el drive y acceder a la carpeta compartida a través de las siguientes líneas.<jupyter_code>from google.colab import drive
drive.mount('/content/drive')<jupyter_output>Mounted at /content/drive<jupyter_text>Constantes Recuerda que debes cambiar las constantes a como tu lo necesites. (Si cambia el path de directorio o imagen a probar)<jupyter_code># Directorio a analizar
in_dir = '/content/drive/MyDrive/Datos - Hackathon JusticIA/Evaluacion/Reto2'
# Alguna imagen en específico para analizar en la sección de una sola imagen
path = "/content/drive/MyDrive/Ficheros_Detenidos_Desaparecidos_Morales_Lopez_Delia_Morales_Lopez_Delia-23-.JPG"
# Directorio para guardar la salida del csv
output_dir_path = "/content/drive/MyDrive"<jupyter_output><empty_output><jupyter_text>Importación de librerias importantes<jupyter_code>!pip install "git+https://github.com/caroacostatovany/hackathon_RIIAA2021.git#egg=busquedadesaparecidos&subdirectory=src" --quiet
author = 'caroacostatovany'
repository = 'hackathon_RIIAA2021'
!git clone https://github.com/{author}/{repository}.git
!sudo apt install libleptonica-dev tesseract-ocr libtesseract-dev --quiet
!pip install -U spacy
%tensorflow_version 2.x
import tensorflow as tf
device_name = tf.test.gpu_device_name()
if device_name != '/device:GPU:0':
  raise SystemError('GPU device not found')
print('Found GPU at: {}'.format(device_name))

import timeit
%cd {repository}
import os
import cv2
import numpy as np
import pytesseract
import pandas as pd
import json


# Importamos el visualizador incluido en spacy
from spacy import displacy
from google.colab.patches import cv2_imshow
from PIL import Image
from skimage.transform import rotate
from skimage.io import imread
from skimage.color import rgb2gray

from busquedadesaparecidos.ocr.procesamiento_imagen import escala_grises, eliminar_ruido, skew_angle_hough_transform
from busquedadesaparecidos.utils.limpieza_texto import quitar_caracteres_especiales, quitar_nonascii, quitar_stopwords, convierte_minusculas, renombrar_clases_spacy
from busquedadesaparecidos.ner.busqueda_expediente import encontrar_expediente, convertir_texto_exp_dataframe
from busquedadesaparecidos.ner.spacy import obtener_entidades, guardar_entidades_en_dataframe
from busquedadesaparecidos.ner.similar_words import TargetWords


# Importamos spacy y el modelo en español
import spacy
nlp = spacy.load("es_core_news_lg")<jupyter_output>[nltk_data] Downloading package punkt to /root/nltk_data...
[nltk_data]   Unzipping tokenizers/punkt.zip.
[38;5;2m✔ Download and installation successful[0m
You can now load the package via spacy.load('es_core_news_lg')
[nltk_data] Downloading package punkt to /root/nltk_data...
[nltk_data]   Package punkt is already up-to-date!
[nltk_data] Downloading package stopwords to /root/nltk_data...
[nltk_data]   Unzipping corpora/stopwords.zip.<jupyter_text>Lectura de un directorio<jupyter_code>folder_list=os.listdir(in_dir)

reto_2b_mayus = pd.DataFrame()
reto_2b_minus = pd.DataFrame()
reto_2a = pd.DataFrame() 
df_target_words_gral = pd.DataFrame()

for folders, sub_folders, file in os.walk(in_dir):
    for name in file:
        # Buscamos los formatos que terminan en png, jpg, jpeg dentro del directorio
        if name.lower().endswith((".jpg",".png",".jpeg")):
          path = "{}/{}".format(in_dir, name)
          print("="*100)
          print("Analizando archivo {}".format(path))
          file_name, file_extension = os.path.splitext(path)
          print("Iniciando procesamiento de imagen")
          # Leemos la imagen
          image = rgb2gray(imread(path))
          print("Revisando si la imagen necesita rotación")
          # Utilizamos hough lines por si necesitamos rotación
          image_rotate = rotate(image, skew_angle_hough_transform(image), cval=1)
          image = cv2.normalize(src= image_rotate, dst=None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)
          im_rotada = Image.fromarray(image)
          # Se guarda temporalmente en un archivo
          im_rotada.save('rotada{}'.format(file_extension))
          imagen_rotada = cv2.imread('rotada{}'.format(file_extension))

          # Iniciamos con la eliminación de ruido
          gray_img = escala_grises(imagen_rotada)
          imagen_sin_ruido = eliminar_ruido(gray_img)

          im = Image.fromarray(imagen_sin_ruido)
          save_path = "gray{}".format(file_extension)
          im.save(save_path)

          # utilizamos la paquetería de binarize
          !python binarize/binarize.py -imgpath "{save_path}" -save out_test"{file_extension}"
          
          img = cv2.imread('out_test{}'.format(file_extension))
          kernel = np.ones((2, 2),np.uint8)
          closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
          dilation = cv2.erode(closing, kernel,iterations = 1)
          print("Procesamiento de imagen terminada")

          print("Iniciando OCR")
          # Utilizamos pytesseract para obtener el texto de la imagen
          texto_extraido = pytesseract.image_to_string(dilation)
          print("OCR terminado")


          if texto_extraido is None:
            print("No se encontró texto en {}".format(path))
          else:
            print("Iniciando análisis de similitudes")
            # Se buscan similitudes 
            tw_prosecuted = TargetWords(texto_extraido, 'prosecuted')
            tw_organization = TargetWords(texto_extraido, 'organization')
            tw_states = TargetWords(texto_extraido, 'state')

            json_prosecuted = json.dumps(tw_prosecuted.results)
            json_organization = json.dumps(tw_organization.results)
            json_states = json.dumps(tw_states.results)

            df_target_words = pd.DataFrame([(json_prosecuted, json_organization, json_states, path)], 
                                           columns=['personas', 'organizaciones', 'estados', 'filename'])
            
            df_target_words_gral = pd.concat([df_target_words_gral, df_target_words])


            print("Iniciando limpieza de texto")
            # Se limpia
            texto_limpio = quitar_caracteres_especiales(texto_extraido)
            texto_limpio = quitar_nonascii(texto_limpio)
            texto_limpio = quitar_stopwords(texto_limpio)
            texto_limpio_minusculas = convierte_minusculas(texto_limpio)
            print("Limpieza de texto terminada")
            print("Iniciando búsqueda de expediente")
            exp = encontrar_expediente(texto_limpio_minusculas)
            print(exp)
            df_exp = convertir_texto_exp_dataframe(path, exp, texto_limpio_minusculas)
            reto_2a = pd.concat([reto_2a, df_exp])
            print("Búsqueda de expediente finalizada")
            
            print("Iniciando clasificación de entidades")
            #doc_mayus = obtener_entidades(texto_limpio)
            #df_mayus = guardar_entidades_en_dataframe(doc_mayus, path)
            #reto_2b_mayus = pd.concat([reto_2b_mayus, df_mayus])

            doc_minus = obtener_entidades(texto_limpio_minusculas)
            df_minus = guardar_entidades_en_dataframe(doc_minus, path)
            reto_2b_minus = pd.concat([reto_2b_minus, df_minus])
            print("Clasificación de entidades finalizada")


#reto_2b_mayus = renombrar_clases_spacy(reto_2b_mayus)
reto_2b_minus = renombrar_clases_spacy(reto_2b_minus)

reto_2a.to_csv("{}/reto_2a.csv".format(output_dir_path))
#reto_2b_mayus.to_csv("{}/reto_2b_mayus.csv".format(output_dir_path))
reto_2b_minus.to_csv("{}/reto_2b.csv".format(output_dir_path))
df_target_words_gral.to_csv('{}/similitud.csv'.format(output_dir_path))<jupyter_output>====================================================================================================
Analizando archivo /content/drive/MyDrive/Datos - Hackathon JusticIA/Evaluacion/Reto2/Ficheros_ACNR_militantes_Olea_Castaneyra_Rafel_Olea_Castaneyra_Rafael,_ACNR-19-.JPG
Iniciando procesamiento de imagen
Revisando si la imagen necesita rotación
[-0.61858396]
2021-08-23 14:44:37.117434: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 14:44:37.129287: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 14:44:37.130099: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so retur[...]<jupyter_text>---Aquí termina lectura de directorio---  Lectura de una imagen (sin guardar output en csv)<jupyter_code># Leemos la imagen
image = rgb2gray(imread(path))
file_name, file_extension = os.path.splitext(path)<jupyter_output><empty_output><jupyter_text>Procesamiento de imagen  Rotación de imagen si es necesaria<jupyter_code>#image_rotate vareable
image_rotate = rotate(image, skew_angle_hough_transform(image), cval=1)
image = cv2.normalize(src= image_rotate, dst=None, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX, dtype=cv2.CV_8U)
im_rotada = Image.fromarray(image)
im_rotada.save('rotada{}'.format(file_extension))<jupyter_output>[-0.04562616]<jupyter_text>------<jupyter_code>imagen_rotada = cv2.imread('rotada{}'.format(file_extension))

gray_img = escala_grises(imagen_rotada)
imagen_sin_ruido = eliminar_ruido(gray_img)
im = Image.fromarray(imagen_sin_ruido)
save_path = "gray{}".format(file_extension)
im.save(save_path)
!python binarize/binarize.py -imgpath "{save_path}" -save out_test"{file_extension}"
img = cv2.imread('out_test{}'.format(file_extension))
kernel = np.ones((2, 2),np.uint8)
closing = cv2.morphologyEx(img, cv2.MORPH_CLOSE, kernel)
dilation = cv2.erode(closing, kernel,iterations = 1)
cv2_imshow(dilation)<jupyter_output><empty_output><jupyter_text>OCR<jupyter_code>texto_extraido = pytesseract.image_to_string(dilation)
texto_extraido
tw_prosecuted = TargetWords(texto_extraido, 'prosecuted')
tw_organization = TargetWords(texto_extraido, 'organization')
tw_states = TargetWords(texto_extraido, 'state')
json_prosecuted = json.dumps(tw_prosecuted.results)
json_organization = json.dumps(tw_organization.results)
json_states = json.dumps(tw_states.results)
df_target_words = pd.DataFrame([(json_prosecuted, json_organization, json_states, path)], columns=['personas', 'organizaciones', 'estados', 'filename'])
df_target_words<jupyter_output><empty_output><jupyter_text>Limpieza de texto<jupyter_code>texto_limpio = quitar_caracteres_especiales(texto_extraido)
texto_limpio = quitar_nonascii(texto_limpio)
texto_limpio = quitar_stopwords(texto_limpio)
texto_limpio
texto_limpio_minusculas = convierte_minusculas(texto_limpio)
texto_limpio_minusculas<jupyter_output><empty_output><jupyter_text>EXP<jupyter_code>x = encontrar_expediente(texto_limpio_minusculas)
df_exp = convertir_texto_exp_dataframe(path, x, texto_limpio_minusculas)
df_exp<jupyter_output><empty_output><jupyter_text>NER  Texto utilizando mayus<jupyter_code>doc = obtener_entidades(texto_limpio)
# Se muestran las entidades con el visualizador
for sent in doc.sents:
    displacy.render(nlp(sent.text),style='ent',jupyter=True)
# Se extraen las entidades con su tipo
df_mayus = guardar_entidades_en_dataframe(doc, path)
df_mayus = renombrar_clases_spacy(df_mayus)
df_mayus<jupyter_output><empty_output><jupyter_text>Texto todo en minusculas<jupyter_code>doc = obtener_entidades(texto_limpio_minusculas)
# Se muestran las entidades con el visualizador
for sent in doc.sents:
    displacy.render(nlp(sent.text),style='ent',jupyter=True)
# Se extraen las entidades con su tipo
df_minus = guardar_entidades_en_dataframe(doc, path)
df_minus = renombrar_clases_spacy(df_minus)
df_minus<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10108303249097472, 'fraction_numerical': 0.014692301234153304, 'mean_word_length': 4.914597815292949, 'pattern_counts': {'":': 0, '<': 45, '<?xml version=': 0, '>': 45, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '12', 'dir': 'jupyter-structured-clean-dedup', 'id': '27514', 'license': 'MIT', 'n_tokens_mistral': 4324, 'n_tokens_neox': 4209, 'n_words': 790, 'path': 'notebooks/pipeline.ipynb', 'repo_name': 'caroacostatovany/hackathon_RIIAA2021', 'size': '11911'}