!curl -O https://raw.githubusercontent.com/mcd-unison/corrector-ortografico/main/quijote.txt
!curl -O https://raw.githubusercontent.com/mcd-unison/corrector-ortografico/main/viage_parmaso.txt
!curl -O https://raw.githubusercontent.com/mcd-unison/corrector-ortografico/main/cien-años-de-soledad.txt

import re
from collections import Counter

def words(text): return re.findall(r'\w+', text.lower())  

WORDS = Counter(words(open('quijote.txt', encoding='latin-1').read()))

WORDS.most_common(30) ## los 30 tipos más frecuentes

N = sum(WORDS.values()) 
V = len(WORDS)
print('Longitud de El Quijote (N): ' + 
      str(N) + '\n' + 
      'Tamaño del vocabulario del El Quijote (V): ' + 
      str(V))

Longitud de El Quijote (N): 376516
Tamaño del vocabulario del El Quijote (V): 22602

import plotly.express as px

def histo_palabras(dicionario, inferior, superior, title_str):
    temp = dict(
        [(key, val) for key, val in dicionario.items() 
         if inferior <= val <= superior])
    x = list(temp.values())

    fig = px.histogram(x, text_auto=True, title=title_str)
    fig.update_layout(showlegend=False)
    
    return fig

title_str = 'Histograma de frecuencias de palabras en El Quijote que aparecen de 1 a 10 veces'

histo_palabras(WORDS, 1, 10, title_str).show()

title_str = 'Histograma de frecuencias de palabras en El Quijote que aparecen de 10 a 200 veces'

histo_palabras(WORDS, 10, 200, title_str).show()

title_str = 'Histograma de frecuencias de palabras en El Quijote que aparecen de 200 a 2500 veces'

histo_palabras(WORDS, 200, 2500, title_str).show()

title_str = 'Histograma de frecuencias de palabras en El Quijote que aparecen de 8000 a 21000 veces'

histo_palabras(WORDS, 8000, 21000, title_str).show()

WORDS_hapax = dict([(key, val) for key, val in WORDS.items() if  val == 1])
WORDS_hapax

tasa_hápax = len(WORDS_hapax)/V
print('Tasa de hápax: ' + str(tasa_hápax) + ' 🤨')

Tasa de hápax: 0.486859569949562 🤨

import numpy as np

H = 100 * np.log(N)/(1-tasa_hápax)

print('Índice de riqueza léxica de (todo) El Quijote: ' + str(H.round(2)))

Índice de riqueza léxica de (todo) El Quijote: 2501.99

import pandas as pd

skip_min =  WORDS['dulcinea']
skip_max = WORDS['quijote']

WORDS_reducido = dict(
    [(key, val) for key, val in WORDS.items() 
     if skip_min <= val <= skip_max])

vocabulario_reducido = pd.DataFrame(
    WORDS_reducido.items(), 
    columns = ['palabra','frecuencia']
).sort_values(by='frecuencia')

fig = px.bar(
    vocabulario_reducido, 
    x='palabra', y='frecuencia', color = 'frecuencia')
fig.show()

def known(words): 
    "Subconjunto de palabras que aparecen en el diccionario WORDS."
    return set(w for w in words if w in WORDS)

def edits1(word):
    "Palabras a una distancia _____ de edición de  `word`."
    letters    = 'abcdefghijklmñnopqrstuvwxyzáéíóú'
    splits     = [(word[:i], word[i:])    for i in range(len(word) + 1)]
    deletes    = [L + R[1:]               for L, R in splits if R]
    replaces   = [L + c + R[1:]           for L, R in splits if R for c in letters]
    inserts    = [L + c + R               for L, R in splits for c in letters]
    return set (deletes  + replaces + inserts)

def edits2(word): 
    "Palabras a una distancia _____ de edición de  `word`."
    return set(e2 for e1 in edits1(word) for e2 in edits1(e1))

'ayer' in edits2('aller')

def candidates_version_preliminar(word): 
    "Posibles canditados a ser la corrección de `word`."
    return known(edits2(word))

candidates_version_preliminar('af')

candidates_version_preliminar('alf')

candidates_version_preliminar('dulcinea')

candidates_version_preliminar('dulsinea')

candidates_version_preliminar('zancho')

candidates_version_preliminar('internet')

V = len(WORDS)
N = sum(WORDS.values())

def P(word): 
    "Probabilidad de `word`"
    return WORDS[word] / N

[P('el'), P('quijote'), P('no'), P('usaba'), P('internet')]

[0.021449287679673638,
 0.005726184279021343,
 0.016665958418765735,
 1.0623718513954255e-05,
 0.0]

def logP(word): 
    "Log-probabilidad de `word`"
    return np.log(P(word))

def distribution(diccionario):
    "Distribucción de probabilidad de los valores de `diccionario`"
    return list(P(w) for w in diccionario)

def distributionlog(diccionario):
    "Distribucción de log-probabilidad de los valores de `diccionario`"
    return list(logP(w) for w in diccionario)

fig = px.violin(
    distribution(WORDS), 
    title='Distribución de probabilidad modelo de lenguaje')
fig.show()

fig = px.violin(
    distributionlog(WORDS), 
    title='Distribución de log-probabilidad modelo de lenguaje')
fig.show()

def P_Laplace(word,k): 
    "Probabilidad de `k`-Laplace de la palabra `word`"
    return (WORDS[word] + k) / (N + k * V)

def distribution_Laplace(diccionario,k):
    "Distribucción de probabilidad  `k`-Laplace de los valores de `diccionario`"
    return list(P_Laplace(w,k) for w in diccionario)

def candidates(word): 
    return (known([word]) or known(edits1(word)) or known(edits2(word)) or [word])

candidates('af')

{'a', 'ad', 'ah', 'al', 'ay'}

candidates('alf')

{'al', 'ala', 'alá'}

candidates('dulcinea')

{'dulcinea'}

candidates('dulsinea')

{'dulcinea'}

candidates('zancho')

{'ancho', 'gancho', 'rancho', 'sancho'}

candidates('internet')

['internet']

'internet' in known(edits1('internet'))

False

known(edits1('sancho')).issubset(known(edits1('sancho')))

True

def correction(word): 
    "Error más probable de `word`."
    return max(candidates(word), key=logP)

correction('af')

'a'

correction('alf')

'al'

candidates('internet')

['internet']

correction('zancho')

'sancho'

correction('pusiéredes')

'pudiéredes'

def spelltest(tests, verbose=False):
    "Ejecuta la corrección a la entrada `wrong` de  en todos los pares (`right`, `wrong`); reporta resultados."
    import time
    start = time.perf_counter()
    good, unknown = 0, 0
    n = len(tests)
    for right, wrong in tests:
        w = correction(wrong)
        good += (w == right)
        if w!= right:
            unknown += (right not in WORDS)
            if verbose:
                print(f'correction({wrong}) => {w} ({WORDS[w]}); expected {right} ({WORDS[right]})')

    dt = time.perf_counter() - start
    print(f"{good/n:.0%} de {n} correciones ({unknown/n:.0%} desconocidos) a {n/dt:.0f} palabras por segundo")

def genera_pares(original,dictado):
    "Regresa lista de pares (`right`, `wrong`)"
    test = []
    for i in range(len(original)):
        if original[i] != dictado[i]:
            test.append((original[i],dictado[i]))
    return test

texto_prueba = re.sub(
    r'[^\w+]|_', ' ', 
    open('viage_parmaso.txt', encoding='utf-8').read().lower()
)

texto = 'peregrinas veras  si en ello adviertes y reparas  que es una este bagel de las mas dinas de admiracion'.split()

texto_dictado= 'peregrinas verás si en ello adviertees y reparasd que es una este bagel de las smas dinas de admiracion'.split()

test = genera_pares(texto,texto_dictado)
test

[('veras', 'verás'),
 ('adviertes', 'adviertees'),
 ('reparas', 'reparasd'),
 ('mas', 'smas')]

spelltest(test)

75% de 4 correciones (0% desconocidos) a 4513 palabras por segundo

correction('ambrosía')

'ambrosio'

1. ¿Cómo funciona un corrector ortográfico?¶

2. Elementos de un modelo probabilístico generativo¶

3. Metodología para la creación de un autocorrector¶

3.1. Obtención del corpus¶

3.2. Creación de vocabulario y análisis exploratorio¶

3.2.1. Análisis de datos¶

3.3. Creación de candidatos dado una palabra 𝑤¶

3.4. Estimación del mejor candidato¶

Estrategia para calcular $P(c)$ (modelo de lenguaje)¶

Estrategia para «calcular» $P(w|c)$ (modelo de error)¶

Estimación final¶

3.5. Evaluación del modelo¶

4. Trabajo futuro¶

📖¶