first deploy

app.py

@@ -2,28 +2,86 @@ import gradio as gr
 import pandas as pd
 import numpy as np
 import pickle
+import nltk
+from nltk import word_tokenize 
+from nltk.util import ngrams
+from unidecode import unidecode
 
+# leemos diccionario de entidades
+diccionario = pd.read_excel('diccionario.xlsx')
+diccionario = diccionario.iloc[1:]
+all_dicts = diccionario.apply(lambda x: {x['Entidad']: x['Categoria']}, axis = 1)
 
-remote_df = pd.read_excel('test_df.xlsx')
+# formateamos diccionario
+entities_dict = {}
+for i in all_dicts:
+  entities_dict.update(i)
 
-def predict(x1, x2):
+def predict(text):
 
-  X = np.array([x1, x2], ndmin = 2)
+  diccionario = entities_dict.copy()
+  tokens = word_tokenize(text, language = 'spanish')
+  tokens_lower = [unidecode(token.lower()) for token in tokens] # tokens en minuscula
 
-  with open('test_model.pkl', 'rb') as model:
-    clf = pickle.load(model)
+  dict_tokens = {tokens_lower[i]: tokens[i] for i in range(len(tokens))}
+  dict_keys = {unidecode(key.lower()): key for key in diccionario.keys()}
 
-  y_pred = clf.predict(X)
+  # presencia de ngrams
+  ngram_range = 5 # rango de ngramas a evaluar
+  nmin = 1 # numero minimo de ngramas presente en el texto
+  grams_detected = {}
+  for i in range(2, ngram_range + 1):
+    n_grams = [' '.join(ngram) for ngram in list(nltk.ngrams(tokens_lower, i))]
+    intersection = list(set(n_grams) & set(dict_keys.keys()))
+    if len(intersection) > 0:
+      nmin = i
+      grams_detected.update({nmin: intersection})
 
-  return y_pred + remote_df['col1'][0]
+  sep = '%$·'
+  tmp_text = text
+  for i in range(5, 1, -1):
+    try:
+      # obtener todos los ngramas de nivel "i"
+      for j in range(len(grams_detected[i])):
+        tmp_text = tmp_text.replace(grams_detected[i][j], f'{i}{sep}{j}')
+    except KeyError: # en caso de que no existan ngramas de nivel "i", pass
+      pass
+
+  labeled_tokens = []
+  # si hay solo entidades de largo 1, devuelvo oracion etiquetada token a token
+  if nmin < 2:
+    for token in tokens_lower:
+      labeled_tokens.append((dict_tokens[token], diccionario[dict_keys[token]]) if token in dict_keys.keys() else (token, None))
+
+    return labeled_tokens
+
+  # si hay entidades de largo 2 o mas, devuelvo solo las entidades etiquetadas
+  else:
+    tmp_text = ' '.join(tmp_text.split()) # texto sin espacios
+    tmp_tokens = tmp_text.split()
+    for token in tmp_tokens:
+      if sep in token:
+        level, pos = token.split(sep)
+        encoded_token = grams_detected[int(level)][int(pos)]
+        labeled_tokens.append((encoded_token, diccionario[dict_keys[encoded_token]]))
+      elif token in dict_keys.keys():
+        labeled_tokens.append((dict_tokens[token], diccionario[dict_keys[token]]))
+      else:
+        labeled_tokens.append((token, None))
+      
+    return labeled_tokens
 
 demo = gr.Interface(
     predict,
-    inputs = [gr.Number(), gr.Number()],
-    outputs = gr.Number(),
+    gr.Textbox(placeholder = "Ingresa el texto acá", label = 'Texto'),
+    gr.Highlightedtext(label = 'Etiquetas'),
     examples=[
+        ['hola!! estoy en santiago manejando en mi ferrari que compré en marzo'],
+        ['este septiembre iremos manejando a temuco en un toyota para pasar las fiestas patrias'],
+        ['no puedo, tengo que irme desde san pedro de la paz hasta santiago'],
+        ['no puedo, tengo que irme desde san pedro hasta la reina y luego hasta san pedro de la paz']
     ],
-    title = 'Deploy Test'
+    title = 'Detección de Entidades'
 )
 
-demo.launch()
+demo.launch()

requirements.txt

@@ -1,4 +1,6 @@
 pandas
 numpy
 openpyxl
-scikit-learn
+scikit-learn
+nltk
+unidecode