Alfabeto Matriz Transición

Referencia: Ross 2.2 p25, Telex, TTY o teletipo(Wikipedia)

Funciones de Matriz de transición de alfabeto

Es posible determinar la matriz de transición entre las letras del alfabeto continuando con el ejercicio de Funciones de probabilidad o masa.

Para procesar el texto se usa como entrada un archivo en formato .txt, analizando por línea, por símbolo y contando las veces que hay transición desde una letra del alfabeto.

Nota: Considere solo el total de letras, no el total de símbolos (no incluye «,;.!?» etc.)

El resultado que se obtiene es la matriz en los archivo adjuntos:

transicionesletras.txt

transicionesletrasfreq.txt

pueden ser importados para otro algoritmo, programa u hoja electrónica

matriz de conteo: 
[[   1 318 440 874   14  31  56  59    8  20  0 729 314  631 27   0   78   43  749  745  210  85  64  1  27 67 38]
 [ 134   0   0   0   86   0   0   0  153   8  0 184   0    2  0  56    0    0  167   67    3  40   0  0   0  1  0]
 [ 427   0  69   0  318   1   0 135 1064   0  2  63   0    0  0 877    0    0   82    0  174 394   0  0   0  0  0]
 [ 677   0   0   0 1872   0   8   1  513   1  0   1  20    0  0 689    0    2   36    0    4  71   5  0   0  0  0]
 [ 155  82 416 229   12  53 134   3   21  60 17 655 340 1921 12  34  112   18 1328 1479  138  27  61 24 139 37 40]
 [  45   0   0   0  111   0   0   0  194   0  0  18   0    0  0  48    0    0   25    0    0 160   0  0   0  0  0]
 [  90   0   0   0  104   0   1   0  108   0  1  22   2   30  0 114    0    0  105    2    1 146   0  0   0  0  0]
 [ 261   0   0   0   99   0   0   0   15   0  0   0   3    3  0 183    0    0    1    1    7  42   0  1   0  0  0]
 [ 499 165 439 546  473 123 155   3    0   6  0 143 371  778  4 326   60   12  281  326  285   2 162  0   1  0 37]
 [  29   0   0   0   48   0   0   0    6   0  0   0   0    0  0  46    0    0    0    0    0  29   0  0   0  0  0]
 [  19   0   0   0   12   0   0   0    0   0  0   0   0    0  0   1    0    0    0    0    0   0   0  0   0  0  0]
 [1299   0  19  20  513   3  53   0  281   0  1 172  46    2  0 560    5   28    4   27   97 152  12  0   0  3  0]
 [ 379  80   0   0  531   0   0   0  374   0  0   0   6    2  0 588  312    0   12    1    1  66   0  0   0  1  0]
 [ 501   2 447 379  361  63  86   0  385   6  1   0  33   13  0 541    1   16    2  214 1034 100  38  1   0  0 34]
 [  20   0   0   0    3   0   0   0    0   0  0   0   0    0  0  22    0    0    0    0    0   0   0  0   0  0  0]
 [   0 108 116 197   43  28  54   4   10  12  0 165 404  768  3   0  125    2  628 1356   97   6  18  0   5 11  5]
 [ 334   0  32   0  310   0   0   2  116   0  0 193   0    0  0 560    1    0  412    1   29 222   0  0   0  0  0]
 [   0   0   0   0    0   0   0   0    0   0  0   0   0    0  0   0    0    0    0    0    0 692   0  0   0  0  0]
 [1058  16  74 111  774  22  57   0  486   1  1  40  93   35  0 522   21   13  105  129  191  39  24  0   0  3 51]
 [ 306   2 118  31  576  40   0   2  694   0  2   2  92    0  0 333  150    5    0    4  731 374   2  1   0  0  0]
 [ 840   0   4   0  954   0   1   8  429   0  0   3   0    3  0 771    0    0  475    1    6 150   0  0   0  0  4]
 [ 232  50 100  54  976   9  25   1  134   5  0 166  82  758  0  12   69    0  115  166   83   0   9  0   0 38  9]
 [ 112   0   0   0  272   0   0   0  168   0  0   0   0    0  0  68    0    0    1    0    0  10   0  0   0  0  0]
 [   0   0   0   0    9   0   0   0    1   0  0   0   0    0  0   0    0    0    0    1   21   0   0  0   0  0  0]
 [  14   0  13   0    0   0   0   0   81   0  0   0   0    0  0   0   46    0    0    0   21   0   0  0   0  0  0]
 [  33   0   0   0   22   0   0   0    0   0  0   0   0    2  0  36    0    0    0    0    0   2   0  0   0  0  0]
 [ 117   0   7   0    0   0   3   0    0   0  0   0   0    0  0  22    0    0    0    0    2   3   0  0   0  0  0]]
matriz de conteo:
[[  1.77e-04  5.64e-02  7.81e-02  1.55e-01   2.48e-03  5.50e-03  9.94e-03  1.04e-02   1.42e-03  3.55e-03  0.00e+00  1.29e-01   5.57e-02  1.12e-01  4.79e-03  0.00e+00   1.38e-02  7.63e-03  1.33e-01  1.32e-01   3.73e-02  1.51e-02  1.13e-02  1.77e-04   4.79e-03  1.19e-02  6.75e-03]
 [  1.48e-01  0.00e+00  0.00e+00  0.00e+00   9.54e-02  0.00e+00  0.00e+00  0.00e+00   1.69e-01  8.87e-03  0.00e+00  2.04e-01   0.00e+00  2.21e-03  0.00e+00  6.21e-02   0.00e+00  0.00e+00  1.85e-01  7.43e-02   3.32e-03  4.43e-02  0.00e+00  0.00e+00   0.00e+00  1.10e-03  0.00e+00]
 [  1.18e-01  0.00e+00  1.91e-02  0.00e+00   8.81e-02  2.77e-04  0.00e+00  3.74e-02   2.95e-01  0.00e+00  5.54e-04  1.74e-02   0.00e+00  0.00e+00  0.00e+00  2.43e-01   0.00e+00  0.00e+00  2.27e-02  0.00e+00   4.82e-02  1.09e-01  0.00e+00  0.00e+00   0.00e+00  0.00e+00  0.00e+00]
 ...
 [  7.59e-01  0.00e+00  4.54e-02  0.00e+00   0.00e+00  0.00e+00  1.94e-02  0.00e+00   0.00e+00  0.00e+00  0.00e+00  0.00e+00   0.00e+00  0.00e+00  0.00e+00  1.42e-01   0.00e+00  0.00e+00  0.00e+00  0.00e+00   1.29e-02  1.94e-02  0.00e+00  0.00e+00   0.00e+00  0.00e+00  0.00e+00]]

Instrucciones en Python

# procesar un archivo de texto
# Determinar la matriz de transición
# para las letras del alfabeto(incluye ñ)
import numpy as np

# INGRESO
# archivo=input('archivo a leer.txt: ')
nombrearchivo =' eureka_poe_edgar_allan.txt'

# PROCEDIMIENTO
alfabeto = 'abcdefghijklmnñopqrstuvwxyz'
k = len(alfabeto)
matriz     = np.zeros(shape=(k,k),dtype=int)
transicion =
np.zeros(shape=(k,k),dtype=float)
total = 0

# procesa el archivo
archivo  = open(nombrearchivo,'r')
unalinea = archivo.readline()
while not(unalinea == ''):
    unalinea = unalinea.strip('\n')
    unalinea = unalinea.lower()
    m = len(unalinea)
    for j in range(0,m-1,1):
        unsimbolo = unalinea[j]
        donde = alfabeto.find(unsimbolo)
        siguiente = unalinea[j+1]
        dondesig  = alfabeto.find(siguiente)
        if (donde>=0 and dondesig>=0):
            #Si no encuentra es negativo
            matriz[donde][dondesig] = matriz[donde][dondesig]+1
            total = total + 1
    unalinea = archivo.readline()
archivo.close()

# Determina matriz de transicion
for i in range(0,k,1):
    suma = np.sum(matriz[i,:])
    transicion[i]=matriz[i,:]/suma

# Salida
print('matriz de conteo: ')
print(matriz)
print('matriz de transición:')
print(transicion)
np.savetxt('transicionletras.txt',matriz, fmt='%d')
np.savetxt('transicionletrasfreq.txt',transicion)

PMF – Teclado Qwerty

Referencia: Teclado Qwerty Wikipedia

Uso del teclado QWERTY

El nombre del teclado QWERTY proviene de las primeras seis letras de su fila superior, fue diseñado y patentado por Christopher Sholes en 1868 y vendido a Remington en 1873.

La distribución QWERTY se diseñó con objetivo de separar las letras más usadas de la zona central del teclado, para evitar que se atascaran las máquinas de escribir de primera generación. Actualmente, ésta propiedad no es más requerida, sin embargo se ha heredado la distribución en los teclados de computadora.

A partir de la frecuencia de uso de las letras del alfabeto, se requiere conocer la frecuencia de uso de cada fila del teclado. Los valores de frecuencia para cada letra se encuentran en el archivo: usoletras.txt que por cada línea registra la letra y frecuencia relativa separadas por una coma ‘,’.

archivo: usoletras.txt:
a, 0.11422682511 
b, 0.0118959769969 
c, 0.0464006717728 
d, 0.0543525280541 
...

Algoritmo en Python

# Analiza teclado QWERTY
# Datos desde Archivo 'usoletras.txt'
import numpy as np

# Ingreso
narchivo = input('Nombre del archivo:')
veces    = []
archivo  = open(narchivo,'r')
linea    = archivo.readline()
while not(linea == ''):
    partes = linea.split(',')
    letra  = partes[0]
    frecuencia = float(partes[1])
    veces.append([letra,frecuencia])
    linea = archivo.readline()
archivo.close()

# PROCEDIMIENTO
superior = 'qwertyuiop'
media    = 'asdfghjklñ'
inferior = 'zxcvbnm'
k = len(veces)
usofila = np.zeros(3,dtype=float)
for i in range(0,len(veces),1):
    if (veces[i][0] in superior):
        usofila[0] = usofila[0]+veces[i][1]
    if (veces[i][0] in media):
        usofila[1] = usofila[1]+veces[i][1]
    if (veces[i][0] in inferior):
        usofila[2] = usofila[2]+veces[i][1]

# SALIDA
print(usofila)

resultado:

[ 0.48999975  0.32815084  0.18184941]

La gráfica para pmf se obtiene al añadir las instrucciones:

# GRAFICA
% matplotlib inline
import matplotlib.pyplot as plt
plt.stem([0,1,2],usofila)
plt.title('PMF filas teclado QWERTY')
plt.xlabel('fila superior, media e inferior')
plt.show()

Tarea: En cada caso, realice la gráfica de funciones de probabilidad de masa (pmf) y la función de probabilidades acumulada (cdf)

  • Encuentre la frecuencia de uso de cada mano, presente la división propuesta de el teclado en dos partes: izquierda y derecha.
  • Realice el ejercicio para determinar la frecuencia de uso de cada dedo de cada mano. Presente un modelo gráfico de cada tecla, para mostrar de mejor forma la medida a obtener
  • con los resultados de éste ejercicio, considere llenar la siguiente tabla:
    mano izquierda mano derecha total fila
    superior
    media
    inferior
    total mano

PMF – Alfabeto

Referencia: Ross 2.2 p25, Telex, TTY o teletipo(Wikipedia)

Funciones de probabilidad de masa para alfabeto

Para el «TELEX», «TTY», «teletype» o sistema de tranmisión/recepción de mensajes de texto mecanografiados, al desconocer el contenido del mensaje se podría considerar que cada letra presenta un comportamiento aleatorio. Se puede intuir que hay letras que son poco comunes como ‘x’ y otras muy comunes como ‘e’.

Para el modelo se requiere estimar función de probabilidad de masa (pmf), tomando como base solo el alfabeto incluyendo la letra ‘ñ’, sin discriminar mayúsculas y minúsculas.

Para un ensayo, se usaría un texto con una cantidad considerable de letras, como por ejemplo una obra literaria.

Por ejemplo: ‘elaguacate_Letra.txt

Referencia: https://achiras.net.ec/el-aguacate-un-pasillo-ecuatoriano-sin-tiempo/

Para procesar el texto se usa como entrada un archivo en formato .txt, analizando por línea, por símbolo y contando las veces que aparece cada letra del alfabeto. La frecuencia relativa de cada letra respecto al total de letras, permitirá visualizar la forma de la función probabilidad de masa (pmf) para el alfabeto.

Nota: Considere solo el total de letras, no el total de símbolos (no incluye «,;.!?» etc.)

Algoritmo en Python

# procesar un archivo de texto
# Determinar la función de probabilidad de masa
# para las letras del alfabeto(incluye ñ)
import numpy as np

# INGRESO
# archivo=input('archivo a leer.txt: ')
nombrearchivo='elaguacate_Letra.txt'

# PROCEDIMIENTO
alfabeto='abcdefghijklmnñopqrstuvwxyz'
k=len(alfabeto)
veces=np.zeros(k,dtype=int)
total=0
# procesa el archivo
archivo = open(nombrearchivo,'r')
unalinea = archivo.readline()
while not(unalinea==''):
    n=len(unalinea)
    unalinea = unalinea.strip('\n')
    unalinea = unalinea.lower()
    m=len(unalinea)
    for j in range(0,m,1):
        unsimbolo=unalinea[j]
        donde = alfabeto.find(unsimbolo)
        if (donde>=0): #Si no encuentra es negativo
            veces[donde]=veces[donde]+1
            total=total+1
    unalinea = archivo.readline()
archivo.close()

frelativa=veces/total
alfa=np.arange(0,len(alfabeto))

# SALIDA
print('Letras contadas: ', total)
print('i,letra,veces,frelativa')
for i in range(0,len(alfabeto),1):
    print(i, alfabeto[i],veces[i], frelativa[i])

el resultado obtenido es:

Letras contadas:  253
i,letra,veces,frelativa
0 a 25 0.098814229249
1 b 1 0.00395256916996
2 c 5 0.0197628458498
3 d 7 0.0276679841897
4 e 25 0.098814229249
5 f 4 0.0158102766798
6 g 0 0.0
7 h 2 0.00790513833992
8 i 22 0.0869565217391
9 j 1 0.00395256916996
10 k 0 0.0
11 l 15 0.0592885375494
12 m 15 0.0592885375494
13 n 20 0.0790513833992
14 ñ 0 0.0
15 o 24 0.0948616600791
16 p 4 0.0158102766798
17 q 3 0.0118577075099
18 r 16 0.0632411067194
19 s 21 0.0830039525692
20 t 16 0.0632411067194
21 u 16 0.0632411067194
22 v 3 0.0118577075099
23 w 0 0.0
24 x 0 0.0
25 y 7 0.0276679841897
26 z 1 0.00395256916996

para la gráfica se añade al algoritmo:

# GRAFICA
% matplotlib inline
import matplotlib.pyplot as plt
plt.stem(alfa,frelativa)
plt.title('PMF alfabeto')
plt.xlabel(alfabeto)
plt.show()


otro experimento realizado con:
Poe, Edgar Allan. Eureka. Vol. 13. EDAF, 2006.

tiene el siguiente resultado:

Letras contadas:  78598
i,letra,veces,frelativa
0 a 8978 0.11422682511
1 b 935 0.0118959769969
2 c 3647 0.0464006717728
3 d 4272 0.0543525280541
4 e 10455 0.133018651874
5 f 658 0.00837171429298
6 g 818 0.010407389501
7 h 632 0.00804091707168
8 i 5792 0.0736914425303
9 j 161 0.00204839817807
10 k 36 0.000458026921805
11 l 4203 0.0534746431207
12 m 2541 0.0323290668974
13 n 6126 0.0779409145271
14 ñ 46 0.000585256622306
15 o 6725 0.0855619735871
16 p 2271 0.0288938649838
17 q 692 0.00880429527469
18 r 4899 0.0623298302756
19 s 5988 0.0761851446602
20 t 3792 0.0482455024301
21 u 3362 0.0427746253085
22 v 647 0.00823176162243
23 w 34 0.000432580981704
24 x 177 0.00225196569887
25 y 491 0.00624697829461
26 z 220 0.00279905341103

Será necesario que realizar el experimento muchas veces para tener un comportamiento más general, se propone realizar al estudiante su experimento con otros textos.

Con los resultados, se requiere:

  1. Realizar la pmf para vocales
  2. Realizar la pmf para consonantes
  3. determine las letras con menor probabilidad de cada grupo
  4. escriba alguna recomendación para mejorar el experimento
  5. escriba al menos una conlusión

Considere lo siguiente:

Si en una transmisión de texto, por ruido en el canal se cambian aleatoriamente algunos caracteres,

  • ¿Cuáles cambios serían los que afectan menos al mensaje?
  • ¿Cuáles cambios serían los que afectan más al mensaje?

En caso de presentar el resultado de frecuencias relativas en un archivo:

# Archivo
narchivo='usoletras.txt'
archivo=open(narchivo,'w')
for i in range(0,k,1):
    linea=alfabeto[i]+','+str(frelativa[i])+'\n'
    archivo.write(linea)
archivo.close()