Árboles de Decisión

Ph.D DARWIN PATIÑO PEREZ

SEP-2020
 Árboles de Decisión

Contenidos
• Árboles de Decisión
• Sobreajuste
• Recorte (Pruning)
 Investigación Relacionada a los
Árboles de Decisión
• William of Occam inventa el criterio de Occam’s razor -
1320
• Hunt usa el método (CLS) para modelar aprendizaje
humano de conceptos - 1960’s.
• Quinlan desarrolla ID3 con la heurística de ganancia de
información para desarrollar sistemas expertos desde
ejemplos – 1970s
• Breiman, Friedman y otros desarrollan CART
(Classification and Regression Trees) similar a ID3 –
1970s
• Una variedad de mejorar se introducen para acomodar
ruido, características continuas, características
incompletas, mejoras en métodos de división – 1980s
• Quinlan’s actualiza sistemas de decision (C4.5) -1993.
• Weka se incluye una versión en Java de C4.5 llamado
J48.
 Árboles de Decisión
• Clasificadores basados en árboles para instancias (datos)
representados como vectores de características (features).
• Nodos prueban características, hay una rama para cada valor de la
característica, las hojas especifican la categoría.
color color
red green red green
blue blue
shape shape
neg pos B C
circle circle
square triangle square triangle
pos neg neg A B C

• Pueden representar cualquier conjunción (AND) y disyunción (OR)

• Pueden representar cualquier función de clasificación de vectores de
características discretas.
• Pueden ser rescritas como reglas, i.e. disjunctive normal form (DNF).
– red  circle → pos
– red  circle → A
blue → B; red  square → B
green → C; red  triangle → C
 Propiedades de Árboles de
Decisión
• Características (features) continuas (reales) pueden ser
clasificadas al permitir nodos que dividan una
característica real en dos rangos basados en umbrales
(e.g. largo < 3 and largo 3)
• Árboles de clasificación tienen valores discretos en las
ramas, árboles de regresión permiten outputs reales en
las hojas
• Algoritmos para encontrar árboles consistentes son
eficientes para procesar muchos datos de entrenamiento
para tareas de datamining
• Pueden manejar ruido en datos de entrenamiento
• Ejemplos:
– Diagnostico medico
– Análisis de riesgo en crédito
– Clasificador de objetos para manipulador de robot (Tan 1993)
 Árbol de Decisión para PlayTennis

Outlook

Sunny Overcast Rain

Humidity Yes Wind

High Normal Strong Weak

No Yes No Yes
 Árbol de Decisión para PlayTennis

Outlook

Sunny Overcast Rain

Humidity Each internal node tests an attribute

High Normal Each branch corresponds to an

attribute value node
No Yes Each leaf node assigns a classification
Árbol de Decisión para Conjunción
Outlook=Sunny  Wind=Weak

Outlook

Sunny Overcast Rain

Wind No No

Strong Weak

No Yes
Árbol de Decisión para Disyunción
Outlook=Sunny  Wind=Weak

Outlook

Sunny Overcast Rain

Yes Wind Wind

Strong Weak Strong Weak

No Yes No Yes
 Árbol de Decisión para XOR
Outlook=Sunny XOR Wind=Weak

Outlook

Sunny Overcast Rain

Wind Wind Wind

Strong Weak Strong Weak Strong Weak

Yes No No Yes No Yes

 Árbol de Decisión
• Árboles de decisión representan disyunciones de conjunciones

Outlook

Sunny Overcast Rain

Humidity Yes Wind

High Normal Strong Weak

No Yes No Yes

(Outlook=Sunny  Humidity=Normal)
 (Outlook=Overcast)
 (Outlook=Rain  Wind=Weak)
 Método Top-Down de
Construcción
• Construir un árbol Top-Down usando dividir para conquistar.
<big, red, circle>: + <small, red, circle>: + <small, red, triangle>: +
<small, red, square>: − <big, blue, circle>: − <small, green, triangle>: -
color
red green
blue
<big, red, circle>: +
<small, red, circle>: +
<small, red, square>: −
<small, red, triangle>: +
 Método Top-Down de
Construcción
• Construir un árbol Top-Down usando dividir para conquistar.
<big, red, circle>: + <small, red, circle>: + <small, red, triangle>: +
<small, red, square>: − <big, blue, circle>: − <small, green, triangle>: -
color
red blue green
<big, red, circle>: + <small, green, triangle>: +
<small, red, circle>: + shape
neg neg
<small, red, square>: − circle <big, blue, circle>: −
square triangle
<small, red, triangle>: +
pos neg pos <small, red, triangle>: +
<big, red, circle>: + <small, red, square>: −
<small, red, circle>: +
 Pseudocódigo para
Construcción de Árbol
DTree(examples, features) returns a tree
If all examples are in one category, return a leaf node with that category label.
Else if the set of features is empty, return a leaf node with the category label that
is the most common in examples.
Else pick a feature F and create a node R for it
For each possible value vi of F:
Let examplesi be the subset of examples that have value vi for F
Add an out-going edge E to node R labeled with the value vi.
If examplesi is empty
then attach a leaf node to edge E labeled with the category that
is the most common in examples.
else call DTree(examplesi , features – {F}) and attach the resulting
tree as the subtree under edge E.
Return the subtree rooted at R.
 Seleccionar una Buena
Característica para Dividir
• Objetivo es tener un árbol que sea lo mas simple posible
(de acuerdo a Occam’s Razor)
• Encontrar un árbol mínimo de decisión (nodos, hojas o
profundidad) es un problema de optimización NP-hard.
• El método top-down que divide para conquistar hace
una búsqueda codiciosa (greedy) para obtener un árbol
simple pero no garantiza que sea el mas simple.
• Se quiere seleccionar una característica que genera
subconjuntos de ejemplos que son similares en una
clase para que estén cerca de ser nodos hojas.
• Hay una variedad de heurísticas para elegir un buen test
o condición, un método popular esta basado en el
incremento de la información (information gain) que se
origino con el sistema ID3 (Quinlan 1979).
 Occam’s Razor
• Occam’s razor: Se debe preferir la hipótesis más corta
que tenga coincidencia (o describa) con los datos
Porque preferir hipótesis cortas?
Argumentos a favor:
– Hay menos hipótesis cortas que largas
– Es poco probable que una hipótesis corta que describa los datos
sea una coincidencia
– Una hipótesis larga que describa los datos puede ser una
coincidencia (sobreajuste o overfitting)
Argumentos en contra:
– Hay muchas maneras de definir hipótesis cortas y una definición
depende de la representación interna del que aprende (i.e. una
representación interna corta para uno puede ser larga para otro)
– Porque el tamaño de la hipótesis es importante?
 Entropía
• Entropía (incertidumbre, desorden, impureza) de un conjunto de
ejemplos S, relativo a una clasificación binaria es:
Entropy (S ) = − p1 log 2 ( p1 ) − p 0 log 2 ( p 0 )
en el cual p1 es la fracción de ejemplos positivos en S y p0 es la
fracción de negativos.
• Si todos los ejemplos están en una categoría, entropía es zero
(definimos 0log(0)=0)
• Si los ejemplos están igualmente mezclados (p1=p0=0.5), entropía
es una máxima de 1.
• Entropía se puede ver como el máximo numero de bits requeridos
en promedio para codificar la clase de un ejemplo en S.
• Para problemas de múltiples clases (multi-class) con c categorías,
la entropía generaliza a:
c
Entropy(S) = ∑ − pi log2 ( pi )
i=1
Grafico de Entropía para
Clasificación Binaria
 Incremento de la Información
• El incremento de información Gain(S, F) ocurre por reduccion
en la entropia esperada al ordenar S basado en atributo F
Sv
Gain(S, F ) = Entropy(S ) − ∑
vValues(F ) S
Entropy(S v )

en el cual Sv es el subconjunto de S que tiene el valor v para

característica F.
• Entropía de cada subconjunto resultante se pondera por su
tamaño relativo.
• Ejemplo:
– <big, red, circle>: + <small, red, circle>: +
– <small, red, square>: − <big, blue, circle>: −
2+, 2 −: E=1 2+, 2 − : E=1 2+, 2 − : E=1
size color shape

big small red blue circle square

1+,1− 1+,1− 2+,1− 0+,1− 2+,1− 0+,1−
E=1 E=1 E=0.918 E=0 E=0.918 E=0
Gain=1−(0.51 + 0.51) = 0 Gain=1−(0.750.918 + Gain=1−(0.750.918 +
0.250) = 0.311 0.250) = 0.311
 Ejemplo: Incremento de la
Información
Gain(S,A)=Entropy(S) - ∑vvalues(A) |Sv|/|S| Entropy(Sv)

Entropy([29+,35-]) = -29/64 log2 29/64 – 35/64 log2 35/64

= 0.99

[29+,35-] A1=? A2=? [29+,35-]

True False True False

[21+, 5-] [8+, 30-] [18+, 33-] [11+, 2-]

 Ejemplo: Incremento de la
Información
Cual atributo es mejor?
[29+,35-] A1=? A2=? [29+,35-]

True False True False

[21+, 5-] [8+, 30-] [18+, 33-] [11+, 2-]

 Ejemplo: Incremento de la
Información
Entropy([21+,5-]) = 0.71 Entropy([18+,33-]) = 0.94
Entropy([8+,30-]) = 0.74 Entropy([11+,2-]) = 0.62
Gain(S,A1)=Entropy(S) Gain(S,A2)=Entropy(S)
-26/64*Entropy([21+,5-]) -51/64*Entropy([18+,33-])
-38/64*Entropy([8+,30-]) -13/64*Entropy([11+,2-])
=0.27 =0.12

[29+,35-] A1=? A2=? [29+,35-]

True False True False

[21+, 5-] [8+, 30-] [18+, 33-] [11+, 2-]

Ejemplo: Datos de Entrenamiento
Day Outlook Temp. Humidity Wind Play Tennis
D1 Sunny Hot High Weak No
D2 Sunny Hot High Strong No
D3 Overcast Hot High Weak Yes
D4 Rain Mild High Weak Yes
D5 Rain Cool Normal Weak Yes
D6 Rain Cool Normal Strong No
D7 Overcast Cool Normal Weak Yes
D8 Sunny Mild High Weak No
D9 Sunny Cold Normal Weak Yes
D10 Rain Mild Normal Strong Yes
D11 Sunny Mild Normal Strong Yes
D12 Overcast Mild High Strong Yes
D13 Overcast Hot Normal Weak Yes
D14 Rain Mild High Strong No
 Ejemplo: Elejir Próximo Atributo
S=[9+,5-] S=[9+,5-]
E=0.940 E=0.940
Humidity Wind

High Normal Weak Strong

[3+, 4-] [6+, 1-] [6+, 2-] [3+, 3-]

E=0.985 E=0.592 E=0.811 E=1.0
Gain(S, Humidity) Gain(S, Wind)
= 0.940-(7/14)*0.985 =0.940-(8/14)*0.811
– (7/14)*0.592 – (6/14)*1.0
= 0.151 = 0.048
Ejemplo: Elejir Próximo Atributo
S=[9+,5-]
E=0.940
Outlook

Over
Sunny Rain
cast

[2+, 3-] [4+, 0] [3+, 2-]

E=0.971 E=0.0 E=0.971
Gain(S, Outlook)
= 0.940-(5/14)*0.971
-(4/14)*0.0 – (5/14)*0.0971
= 0.247
 Ejemplo: Algoritmo ID3

[D1,D2,…,D14] Outlook
[9+,5-]

Sunny Overcast Rain

Ssunny=[D1,D2,D8,D9,D11] [D3,D7,D12,D13] [D4,D5,D6,D10,D14]

[2+,3-] [4+,0-] [3+,2-]
? Yes ?
Gain(Ssunny , Humidity)=0.970-(3/5)0.0 – 2/5(0.0) = 0.970
Gain(Ssunny , Temp.)=0.970-(2/5)0.0 –2/5(1.0)-(1/5)0.0 = 0.570
Gain(Ssunny , Wind)=0.970= -(2/5)1.0 – 3/5(0.918) = 0.019
 Ejemplo: Algoritmo ID3

Outlook

Sunny Overcast Rain

Humidity Yes Wind

[D3,D7,D12,D13]

High Normal Strong Weak

No Yes No Yes

[D1,D2] [D8,D9,D11] [D6,D14] [D4,D5,D10]

Búsqueda en Espacio de Hipótesis (H)
de ID3

+ - +
A2
A1
+ - + + - -
+ - + - - +
A2 A2

- + - + -
A3 A4
+ - - +
Búsqueda en Espacio de Hipótesis (H)
de ID3
• Búsqueda en espacio de hipótesis es completa!
– La función objetiva seguramente esta ahí…
• Output es una hipótesis
• No hay vuelta atrás (backtracking) en los atributos
seleccionados (búsqueda codiciosa)
– Mínima local (divisiones suboptimas)
• Selecciones de búsqueda estadística
– Robusto a ruidos en datos
• Preferencia de inducción (search bias)
– Prefiere árboles cortos que largos
– Pone atributos con alta ganancia de información
cerca de la raíz
 Búsqueda en Espacio de Hipótesis de
ID3
• Desarrolla aprendizaje en grupos (batch learning)
que procesa todas las instancia de entrenamiento
juntos en vez de aprendizaje incremental
(incremental learning) que actualiza una hipótesis
después de cada ejemplo.
• Garantizado de encontrar un árbol consistente con
cualquier conjunto de entrenamiento libre de
conflictos (i.e. vectores idénticos de características
siempre asignados la misma clase), pero no
necesariamente el árbol mas simple.
• Encuentra una hipótesis discreta.
Bias en Inducción de Árbol de Decisión

• Ganancia de información da una

preferencia (bias) para árboles con
profundidad mínima.
• El bias es una preferencia por algunas
hipótesis (un bias de búsqueda) y no una
restricción de hipótesis en el espacio H.
 Ejemplo: Weka
data> java weka.classifiers.trees.J48 -t contact-lenses.arff === Confusion Matrix ===
J48 pruned tree
------------------ a b c <-- classified as 5
tear-prod-rate = reduced: none (12.0) 0 0 | a = soft
1 3 1 | b = hard
tear-prod-rate = normal
2 0 14 | c = none
| astigmatism = no: soft (6.0/1.0)
| astigmatism = yes
| | spectacle-prescrip = myope: hard (3.0)
| | spectacle-prescrip = hypermetrope: none (3.0/1.0)
=== Stratified cross-validation ===
Number of Leaves : 4
Size of the tree : 7 Correctly Classified Instances 20 83.3333 %
Incorrectly Classified Instances 4 16.6667 %
Kappa statistic 0.71
Time taken to build model: 0.03 seconds
Mean absolute error 0.15
Time taken to test model on training data: 0 seconds
Root mean squared error 0.3249
Relative absolute error 39.7059 %
=== Error on training data ===
Root relative squared error 74.3898 %
Total Number of Instances 24
Correctly Classified Instances 22 91.6667 %
Incorrectly Classified Instances 2 8.3333 %
Kappa statistic 0 .8447
Mean absolute error 0.0833 === Confusion Matrix ===
Root mean squared error 0.2041
Relative absolute error 22.6257 % a b c <-- classified as 5
Root relative squared error 48.1223 % 0 0 | a = soft
1 3 1 | b = hard
Total Number of Instances 24
2 2 12 | c = none
 Complejidad Computacional
• Peor caso construye un árbol completo en el cual
cada camino en el árbol prueba cada característica.
Asuma n ejemplos y m características.

F1


Fm
Máximo de n ejemplos esparcidos en todos
los nodos de los m niveles

• En cada nivel, i, en el árbol, se debe examinar las m-i

características que quedan para cada instancia en
ese nivel para calcular las ganancias de información.
m

∑ i
i=1
 n = O(nm 2
)
• En la practica un árbol es raramente completo
(numero de hojas es  n) y la complejidad es lineal
en m y n.
 Árboles de Decisión

Contenidos
• Árboles de Decisión
• Sobreajuste
• Recorte (Pruning)
 Sobreajuste (Overfitting)
• Crear un árbol que clasifique todos los datos de
entrenamiento perfectamente puede no llevarnos a un árbol
con la mejor generalización a datos desconocidos.
– Puede haber error en los datos de entrenamiento que el árbol esta
erróneamente ajustando.
– El algoritmo puede tomar malas decisiones cerca de las ramas
basado en pocos datos que no reflejan tendencias confiables.
• Una hipótesis, h, se dice que sobreajusta (overfits) los
datos de entrenamiento si es que existe otra hipótesis, h´, la
cual tiene más error que h en datos de entrenamiento pero
menos error en datos independientes de prueba.
on training data
accuracy

on test data

hypothesis complexity
 Ejemplo: Sobreajuste
Probando la Ley de Ohm: V = IR (I = (1/R)V)
Experimentalmente
se miden 10 puntos current (I)

Ajustar una curva a

los datos resultantes

voltage (V)

Perfectamente se ajustan a los datos de entrenamiento con un

polinomio de 9no grado (se pueden ajustar n puntos exactamente
con un polinomio de grado n-1)
 Ejemplo: Sobreajuste
Probando la Ley de Ohm: V = IR (I = (1/R)V)

current (I)

voltage (V)

Se mejora la generalización con una función lineal que se ajusta a

los datos de entrenamiento con menor exactitud.
 Sobreajuste de Ruido en
Árboles de Decisión
• Ruido de características o categoría pueden causar
sobreajuste:
– Agregar instancia (dato) ruidosa: <medium, blue, circle>: pos
(pero realmente neg)
color
red green blue
shape neg
neg
circle
square triangle
pos neg pos
 Sobreajuste de Ruido en
Árboles de Decisión
• Ruido de características o categoría pueden causar sobreajuste:
• Agregar instancia (dato) ruidosa: <medium, blue, circle>: pos (pero
realmente neg) color
red green blue <big, blue, circle>: −
shape <medium, blue, circle>: +
neg
circle square triangle small med big
pos neg pos neg pos neg

• Ruido también puede causar que diferentes

instancias del mismo vector de característica tenga
diferentes clases. Es imposible ajustar estos datos y
se debe etiquetar la hoja con la clase de la mayoría.
– <big, red, circle>: neg (but really pos)
• Ejemplos conflictivos pueden surgir si es que las
características son incompletas e inadecuadas.
 Árboles de Decisión

Contenidos
• Árboles de Decisión
• Sobreajuste
• Recorte (Pruning)
 Métodos de Prevención de
Sobreajuste (Recorte o Pruning)
• Dos ideas básicas para árboles de decisión
– Prepruning: Parar de crecer el árbol en algún punto durante
construcción top-down cuando no hay suficientes datos para
toma de decisiones confiables.
– Postpruning: Crecer el árbol completo, entonces eliminar
subarboles que no tengan suficiente evidencia.
• Etiquetar hoja que resulta de un recorte con la clase de
la mayoría de los datos que quedan o con la
distribución de probabilidades de la clase.
• Métodos para elegir subarboles a ser recortados:
– Validacion-cruzada: Reservar algunos datos de entrenamiento
(validation set, tuning set) para evaluar utilidad de
subarboles.
– Test estadístico: Usar un test estadístico en los datos de
entrenamiento para determinar si alguna regularidad
observada se puede eliminar por ser simplemente aleatoria.
– Minimum description length (MDL): Determinar si la
complejidad adicional de la hipótesis es menos compleja que
explícitamente recordar excepciones resultantes del recorte.
 Reduced Error Pruning
• Un método basado en post-pruning y validación cruzada
Partition training data in “grow” and “validation” sets.
Build a complete tree from the “grow” data.
Until accuracy on validation set decreases do:
For each non-leaf node, n, in the tree do:
Temporarily prune the subtree below n and replace it with a
leaf labeled with the current majority class at that node.
Measure and record the accuracy of the pruned tree on the validation set.
Permanently prune the node that results in the greatest increase in accuracy on
the validation set.
 Problemas con Reduced Error
Pruning
• El problema con este método es que
potencialmente “desperdicia” datos de
entrenamiento en el conjunto de validacion.
• Severidad de este problema depende de
adonde estamos en la curva de aprendizaje:
test accuracy

number of training examples

 Validación cruzada sin Perder
Datos de Entrenamiento
• Se modifica el algoritmo de crecimiento para
crecer al ancho primero y se para de crecer
después de llegar a cierta complejidad
especifica de un árbol.
• Requiere varias pruebas de diferentes
recortes usando divisiones aleatorias de
conjuntos de crecimiento y validación
• Se determina la complejidad del árbol y se
calcula un promedio de complejidad C
• Se comienza crecer el árbol de todos los
datos de entrenamiento pero se detiene
cuando la complejidad llega a C.
Otras ideas en Árboles de Decisión
• Mejores criterios de división
– Ganancia de información prefiere características con muchos
valores.
• Características continuas
• Predicción de funciones de valores reales (árboles de
regresión)
• Características con costos
• Costos de misclasificación
• Aprendizaje incremental
– ID4
– ID5
• Grandes bases de datos que no caben en memoria
• Aplicaciones híbridas (i.e. robótica, reconocimiento
patrones, …)
 Árboles de Decisión

Referencias:
1 Mitchel, T., Machine Learning , McGraw Hill, 1997
2 Karray, F., De Silva, C., Soft Computing and Intelligent
Systems Design, Addison Wesley, 2004
3 Mooney, R., Machine Learning Slides, University of Texas
4 Hoffman, F., Machine Learning Slides, Stockholm University
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3

Python 3 para impacientes

"Simple es mejor que complejo" (Tim Peters)

Python IPython EasyGUI Tkinter JupyterLab Numpy

Buscar

Guía rápida de SQLite3 Buscar

Python para impacientes

Python

IPython

EasyGUI

Tkinter
JupyterLab

Numpy

Anexos

Guía urgente de MySQL

Guía rápida de SQLite3

Indice Entradas + populares

Introducción. Instalación de Python, paso a paso

Instalar SQLite. Instalación de Python 3.6 A finales de 2016
se produjo el lanzamiento de Python 3.6 . El
Comandos del gestor. propósito de esta entrada es mostrar, pas...
Tablas. Tipos de datos.
Dar color a las salidas en la consola
Crear/Abrir Base de Datos.
En Python para dar color a las salidas en la
Crear tablas. consola (o en la terminal de texto) existen
varias posibilidades. Hay un método
Operaciones con registros: SELECT, INSERT, UPDATE, DELETE...
basado ...
Declarar una clave primaria (Primary Key).
Declarar una clave externa (Foreign Key). Tkinter: interfaces gráficas en Python
Introducción Con Python hay muchas
Cambiar la estructura de una tabla (ALTER TABLE). posibilidades para programar una interfaz
Borrar una tabla. gráfica de usuario ( GUI ) pero Tkinter es
fácil d...
Operaciones con Vistas.
Operaciones con Índices. Variables de control en Tkinter
Variables de control Las variables de
Operaciones con Triggers.
control son objetos especiales que se
Optimizar una base de datos. asocian a los widgets para almacenar sus
valore...
Garantizar fiabilidad en las transacciones.
Exportar una consulta. Añadir, consultar, modificar y suprimir
Salvar y restaurar una base de datos. elementos en Numpy
Acceder a los elementos de un array. [], [,],
Importar y exportar datos en formato CSV. ... Acceder a un elemento de un array. Para
Caso práctico 1: operaciones con base de datos (redlocal.db). acceder a un elemento se utiliz...

Caso práctico 2: operaciones con base de datos (contactos.db).

Operaciones con fechas y horas.
Calendarios
Los módulos datetime y calendar amplían
las posibilidades del módulo time que
Pequeña, rápida y de confianza provee funciones para manipular
Elige cualquiera de las tres opciones expresiones de ti...

Threading: programación con hilos (I)

En programación, la técnica que permite
que una aplicación ejecute
simultáneamente varias operaciones en el
Introducción mismo espacio de proceso se...

Convertir, copiar, ordenar, unir y dividir

SQLite es un sencillo sistema de gestión de bases de datos de tipo relacional que está escrito arrays Numpy
en lenguaje C, que implementa el estándar del lenguaje de consulta SQL-92. Esta entrada trata sobre algunos métodos
que se utilizan en Numpy para convertir
SQlite no funciona como otros gestores que necesitan de un servidor de base de datos listas en arrays y viceversa; para copiar
arrays d...
ejecutándose en un proceso separado al que se le hacen peticiones. La librería SQLite es tan
pequeña que se enlaza con los programas y éstos hacen llamadas directamente a los Gráficos en IPython
procedimientos y funciones disponibles para interactuar con las bases de datos; siendo este Unos de los motivos que inspiraron el
modo de trabajo más eficiente que el basado en comunicar peticiones a procesos externos.

desarrollo de IPython fue contar con una

herramienta que uniera la posibilidad de
realizar cálcu...
Una base de datos SQLite se almacena en un sólo archivo y, siempre que sea posible,
funcionará completamente en memoria para mejorar su rendimiento. Además, como no tiene Entrada Estándar: input()
dependencias externas es fácilmente portable y convertible.

La función input() permite a los usuarios

introducir datos de distintos tipos desde la
SQLite tiene licencia GPL, está disponible para las plataformas más extendidas (GNU/Linux,

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 1/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3
Windows, MacOSX) y cuenta con librerías y drivers para desarrollar bases de datos con los entrada estándar (normalmente se
corresponde con...
lenguajes de programación más populares (Python, Perl, Java, Ruby, PHP, C, etc.).

Archivo

Instalar SQLite Archivo

En Debian/Ubuntu:

python.org
$ sudo apt-get install sqlite3 libsqlite3-dev

En Windows:

Descargar archivos .zip del apartado "Precompiled Binaries for Windows" de la página de

descargas de SQLite, descomprimir archivos y copiar archivos obtenidos a la ruta

C:\Windows\System32.

pypi.org
En otros sistemas: Android, Mac OS X, Windows Phone 8

Comandos del gestor

Sitios
Una vez instalado el gestor de base de datos para iniciar una sesión de trabajo desde la línea de
comandos, introducir: ActivePython
Anaconda
$ sqlite3

Bpython
Django
A continuación, el sistema comenzará la sesión de trabajo mostrando la siguiente información, y Flask
quedando a la espera de recibir comandos:

Ipython
IronPython
Matplotlib
MicroPython
Numpy
Pandas
Pillow
PortablePython
PyBrain
PyCharm

Comandos más usuales:

PyDev
PyGame
Pypi
Salir: .exit .quit
PyPy
Crear base de datos vacía o abrir existente: .open nombrebase.db
Pyramid
Listar bases de datos abiertas: .databases
Python.org
Listar tablas y vistas de una base de datos abiertai: .tables
PyTorch
Listar tablas utilizando patrones: .tables "prefijo%" .tables "%sufijo" SciPy.org
Listar esquema (estructura): .schema nombretabla ó .fullschema Spyder
Listar índices: .indexes ó .indices Tensorflow
Listar campos de una tabla: PRAGMA table_info("usuarios"); TurboGears
Ejecutar comandos SQL almacenados en un archivo: .read archivo.sql 
Añadir base datos a sesión actual: ATTACH DATABASE "nueva.db" AS nueva;
Ayuda: .help

Tablas. Tipos de datos

Una tabla es el objeto principal de una base de datos por ser el lugar donde se almacena la
información a gestionar. Una base de datos suele contener un conjunto de tablas y por sus
datos, algunas de ellas, pueden estar relacionadas entre sí.

Las tablas se utilizan para organizar la información y se componen de filas y columnas.

Un registro es cada una de las filas en que se divide la tabla y un campo es cada una de las
columnas de la tabla que, normalmente, contienen datos de diferentes tipos.

Tipos de datos:

NULL: Se refiere a los valores nulos o NULL: typeof(NULL) -> null

INTEGER: Números enteros: typeof(100) -> integer
REAL: Números reales: typeof(100.10) -> real
TEXT: Texto: typeof('100') -> text
BLOB: Binario: typeof(x'100') -> blob

Fechas:

Las fechas en SQLITE3 se pueden almacenar en un campo como textos, números reales o
números enteros.

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 2/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3

# Fechas y horas como TEXT:

# Formato: ISO8601 "YYYY-MM-DD HH:MM:SS.SSS"

CREATE TABLE IF NOT EXISTS tabla1 (fecha1 text, fecha2 text);

INSERT INTO tabla1 (fecha1, fecha2) VALUES (datetime('now'),

datetime('now', 'localtime'));

SELECT fecha1, typeof(fecha1), fecha2, typeof(fecha2) FROM tabla1;

# Fechas y horas como REAL:

# Formato: juliano

CREATE TABLE IF NOT EXISTS tabla1 (fecha1 real);

INSERT INTO tabla1 (fecha1) VALUES (julianday('now'));

SELECT fecha1 FROM tabla1;

# Fechas y horas como INTEGER:

# Formato: entero

CREATE TABLE IF NOT EXISTS tabla1 (fecha1 int);

INSERT INTO tabla1 (fecha1) VALUES (strftime('%s','now'));

Consulta valor (entero):

SELECT fecha1 FROM tabla1;

Consulta valor (fecha-hora):

SELECT datetime(fecha1, 'unixepoch') FROM tabla1;

Crear/Abrir Base de Datos

# Crear base de datos vacía (si no existe)

# o abrir base de datos (existente):

$ sqlite3 nombrebase.db

# o bien

sqlite3

.open nombrebase.db

Crear tablas

La sentencia CREATE se utiliza para crear las tablas de una base de datos. En primer lugar, a
cada tabla se le asigna un nombre. Después, se define la lista de campos indicando para cada
uno de ellos el tipo de dato que va a contener (TEXT, INTEGER, REAL, TEXT y BLOB).
Además, cada campo puede incluir en su definición algunas restricciones básicas como NOT
NULL para que no contengan valores nulos o UNIQUE para que no se acepte un mismo dato en
diferentes filas o registros.

También, para garantizar la integridad de los datos de una base de datos pueden existir campos
declarados como PRIMARY KEY (claves primarias) o FOREIGN KEY (claves externas). Ver
apartados correspondientes.

# Ejemplo: Crear tabla "usuarios" y "dptos".

CREATE TABLE usuarios (

id_usu INTEGER PRIMARY KEY AUTOINCREMENT,

cta_usu TEXT UNIQUE,

nombre TEXT NOT NULL,

id_dpto INTEGER,

ecorreo TEXT NOT NULL,

FOREIGN KEY (id_dpto) REFERENCES dptos(id_dpto)

);

CREATE TABLE dptos (

id_dpto INTEGER PRIMARY KEY AUTOINCREMENT,

denom TEXT NOT NULL UNIQUE

);

Operaciones básicas con registros

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 3/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3

INSERT

La sentencia INSERT permite insertar registros en una tabla.

# Insertar un registro:

INSERT INTO tabla1 (campo1, campo2) VALUES (dato1, dato2);

# Insertar múltiples registros:

INSERT INTO tabla1 (campo1, campo2) VALUES (dato11, dato12),

(dato21, dato22);

# Insertar registro con valores por defecto

# (o valores Null) definidos al crear tabla:

CREATE TABLE tabla1 (campo1 INTEGER DEFAULT 1,

campo2 INTEGER DEFAULT 2);

INSERT INTO tabla1 DEFAULT VALUES;

# Insertar registros con los datos de un SELECT:

INSERT INTO tabla2 SELECT campo1, campo2 FROM tabla1;

SELECT

La sentencia SELECT permite consultar los datos almacenados en una base de datos.

# Sintáxis de SELECT:

# SELECT DISTINCT lista_campos

# FROM lista_tablas_o_vista

# JOIN tabla ON condición_de_unión

# WHERE filtro_a_nivel_de_fila

# ORDER BY campo

# LIMIT número OFFSET offset

# GROUP BY campo

# HAVING filtro_a_nivel_de_agrupamiento;

# Claúsulas:

# ORDER BY campo: permite ordenar la consulta por

# nombre o número de campo.

# DISTINCT. En una consulta muestra filas únicas.

# WHERE. Se utiliza para filtrar la consulta a

# nivel de filas.

# LIMIT núm. OFFSET offset. Limita núm. de filas devueltas.

# GROUP BY campo. Agrupa de filas por campo (resumen).

# Devuelve una fila por cada grupo. A cada grupo se le

# puede aplicar una función (MIN, MAX, SUM, COUNT, AVG)

# para obtener más información del grupo.

# HAVING. Aplica filtro (a una agrupación o en una

# agregación).

# INNER JOIN o LEFT JOIN. Permite consultar filas de

# múltiples tablas.

# CASE. Calcula campo a partir de una o más condiciones

# Operadores de comparación:

=, <>, !=, <, >, <= , >=

# Operadores:

# 0, 1, NULL - 0 equivale a FALSE y 1 a TRUE

# ALL, AND, OR, ANY, BETWEEN, EXISTS, IN, LIKE,

# NOT (NOT EXISTS, NOT IN, NOT BETWEEN, etc.)

# Ejemplos de SELECT:

SELECT campo1, campo2 FROM tabla1;

SELECT * FROM tabla1;

SELECT campo1, campo2 FROM tabla1 ORDER BY campo1 ASC, campo2 DESC;

SELECT campo1, campo2 FROM tabla1 ORDER BY campo1 ASC;

SELECT campo1, campo2 FROM tabla1 ORDER BY 2,1;

SELECT DISTINCT campo1 FROM tabla1;

SELECT campo1, campo2 FROM tabla1 WHERE campo1 = 100;

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 4/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3
SELECT campo1, campo2 FROM tabla1 WHERE campo2 IN (1,2,3);

SELECT campo1, campo2 FROM tabla1 WHERE campo3 IN (SELECT campo3

FROM tabla2 WHERE campo4 = 20);

SELECT campo1, campo2, campo3 FROM tabla1 WHERE campo3

NOT IN (1, 2, 3);

SELECT campo1, campo2, campo3 FROM tabla1 WHERE campo3 LIKE 'An%';

SELECT campo1, campo2, campo3 FROM tabla1 WHERE campo1

BETWEEN 10 AND 20;

SELECT campo1, campo2 FROM tabla1 LIMIT 10;

SELECT campo1, campo2 FROM tabla1 LIMIT 10 OFFSET 10;

SELECT campo1, campo2 FROM tabla1 WHERE campo2 LIKE '%Br';

SELECT campo1, campo2 FROM tabla1 WHERE campo2 LIKE '%Br_wn%';

SELECT campo1, campo2 FROM tabla1 WHERE campo2 GLOB 'Man*';

SELECT campo1, campo2 FROM tabla1 WHERE campo2 GLOB '*Man';

SELECT campo1, campo2 FROM tabla1 WHERE campo2 GLOB '?ere*';

SELECT campo1, campo2 FROM tabla1 WHERE campo2 GLOB '*[1-9]*';

SELECT campo1, COUNT(campo2) FROM tabla1 GROUP BY campo3;

SELECT campo1, COUNT(campo2) FROM tabla1 GROUP BY campo2

HAVING campo3 = 1;

SELECT campo1, campo2 CASE WHEN campo3 < 3 THEN '1'

WHEN campo3 > 3 AND campo3 < 6 THEN '2'

ELSE '3' END valor FROM tabla1;

# Seleccionar registros coincidentes de ambas

# tablas y los que no coincidan de tabla1:

SELECT campo1, tabla1.campo2, tabla2.campo2, campo3 FROM tabla1

LEFT JOIN tabla2 ON tabla2.campo2 = tabla1.campo2

# Seleccionar registros coincidentes de ambas tablas:

SELECT campo1, tabla1.campo2, tabla2.campo2, campo3 FROM tabla1

INNER JOIN tabla2 ON tabla2.campo2 = tabla1.campo2

# Seleccionar registros coincidentes y no

# coincidentes de ambas tablas:

SELECT * FROM tabla1 FULL OUTER JOIN tabla2 ON

tabla1.campo1 = tabla2.campo1;

# Combinar dos o más conjuntos de resultados:

SELECT campo1, campo2 FROM tabla1 CROSS JOIN tabla2 ORDER BY campo2;

# Combinar conjuntos de resultados de dos o

# más consultas en un único conjunto de

# resultados (UNION y UNION ALL: UNION elimina

# filas duplicadas y UNION ALL no):

consulta_1 UNION [ALL] consulta_2 UNION [ALL] consulta_3 ...;

SELECT campo1, campo2 FROM tabla1 UNION SELECT campo1, campo2

FROM tabla2 ORDER BY campo1, campo2;

UPDATE

La sentencia UPDATE se utiliza para actualizar datos en los registros o filas de una tabla.

# Actualizar un campo en registros que cumplan una condición:

UPDATE tabla1 SET campo1 = 'dato1' WHERE campo2 = 3;

# Actualizar varios campos en registros que cumplan una condición:

UPDATE tabla1 SET campo1 = 'dato1', campo2 = 'dato2' WHERE campo3 = 3;

# Actualizar limitando el número de registros:

UPDATE tabla1 SET campo1 = 'dato1' ORDER BY campo2 LIMIT 1;

# En este caso se limita la actualización a

# 1 registro, que será el primero que resulte de

# la ordenación que establece la claúsula ORDER BY

# Actualizar todos los registros:

UPDATE tabla1 SET campo1 = 'dato1';

DELETE

La sentencia DELETE sirve para borrar registros de las tablas de una base de datos.

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 5/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3
# Borrar los registros que cumplan una condición:

DELETE FROM tabla1 WHERE campo1 > 10;

# Borrar todos los registros:

DELETE FROM tabla1;

# Borrar limitando el número de registros:

DELETE FROM tabla1 WHERE campo1 > 10 ORDER BY campo2 LIMIT 2;

REPLACE

Se utiliza para insertar una nueva fila o para reemplazar (borrar una fila existente e insertar una
nueva) en una tabla.

# Cuando sucede una excepción por una

# restricción UNIQUE KEY o PRIMARY:

# En primer lugar, se elimina la fila existente

# que produce la excepción.

# Y después, se inserta la nueva fila.

# Ejemplo

# tabla tabla1:

# campo1, campo2, campo3

# 1, cadena1, 120000

# 2, cadena2, 100000

# 3, cadena3, 150000

# Insertar un nuevo registro con REPLACE

# (no se produce excepción):

# Normalmente, se crea un índice con clave única

# para asegurar que no hay duplicados.

CREATE UNIQUE INDEX indice1 ON tabla1 (campo2);

# En el siguiente ejemplo como no existe un

# registro que contenga la clave "cadena4" REPLACE

# insertará un nuevo registro

REPLACE INTO tabla1 (campo2, campo3) VALUES ('cadena4', 140000);

# campo1, campo2, campo3

# 1, cadena1, 120000

# 2, cadena2, 100000

# 3, cadena3, 150000

# 4, cadena4, 140000

# Actualizar registro con REPLACE

# (se produce excepción):

# En el ejemplo que sigue como existe un

# registro con la clave "cadena1", REPLACE

# borra el registro actual e inserta uno nuevo:

REPLACE INTO tabla1 (campo2, campo3) VALUES ('cadena1', 170000);

# campo1, campo2, campo3

# 2, cadena2, 100000

# 3, cadena3, 150000

# 4, cadena4, 140000

# 5, cadena1, 170000

Declarar una clave primaria (Primary Key)

Una clave primaria es un campo o combinación de campos que identifica de forma única a cada
fila de una tabla.

# Declarar clave primaria de campo único:

CREATE TABLE tabla1 (

campo1 INTEGER PRIMARY KEY,

campo2 TEXT NOT NULL

);

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 6/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3

# En SQL estándar la columna de clave principal

# no debe contener valores NULL. Esto significa

# que la columna de clave principal tiene una

# restricción NOT NULL implícita. Sin embargo,

# para hacer la versión actual de SQLite compatible

# con las versiones anteriores, SQLite permite

# que la columna de clave principal pueda

# contener valores nulos.

# Declarar clave primaria de múltiples campos:

CREATE TABLE tabla1 (

campo1 INTEGER,

campo2 INTEGER,

PRIMARY KEY (campo1, campo2),

...

);

# La columna rowid:

# Cuando se crea una tabla sin especificar

# la opción WITHOUT ROWID, SQLite añade una

# columna llamada rowid que almacena el

# número de fila (entero de 64 bits).

# La columna rowid es una clave que identifica

# de forma unívoca cada fila dentro de la tabla.

SELECT rowid, campo1, campo2 FROM tabla1;

# Añadir clave primaria a una tabla existente:

# SQLite no permite utilizar la sentencia

# ALTER TABLE para agregar una clave principal

# a una tabla existente como puede hacerse

# en MySQL o ProstgreSQL.

# Sin embargo, se puede renombrar la tabla,

# crear una nueva tabla con la misma estructura

# y después importar la tabla renombrada:

PRAGMA foreign_keys=off;

BEGIN TRANSACTION;

ALTER TABLE tabla1 RENAME TO tabla1_anterior;

CREATE TABLE tabla1 (

campo1 integer PRIMARY KEY,

campo2 text NOT NULL

);

INSERT INTO tabla1 SELECT * FROM tabla1_anterior;

DROP TABLE tabla1_anterior;

COMMIT;

PRAGMA foreign_keys=on;

PRAGMA table_info(tabla1);

# Definir una clave primaria autoincrementada:

CREATE TABLE tabla1 (

campo1 INTEGER PRIMARY KEY AUTOINCREMENT,

campo2 TEXT NOT NULL UNIQUE

);

INSERT INTO tabla1 (campo2) VALUES ('dato1'), ('dato2');

Declarar una clave externa (Foreign Key)

Una clave externa es un campo (o varios) que señalan la clave primaria de otra tabla. El
propósito de la clave externa es asegurar la integridad referencial de los datos. La integridad
referencial es un sistema de reglas que utilizan la mayoría de las bases de datos relacionales
para asegurar que los registros de las tablas relacionadas son válidos; y para que no se borren o
cambien datos de forma accidental produciendo errores (de integridad).

# Crear tablas con claves externas:

# Cuando se crea una tabla la claúsula

# FOREIGN KEYS se utiliza para declarar

# la clave externa.

# En la siguiente ejemplo la clave externa

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 7/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3
# "campo3" de "tabla1" está vinculada con

# la clave primaria "campo1" de "tabla2":

CREATE TABLE tabla1 (

campo1 INTEGER PRIMARY KEY AUTOINCREMENT,

campo2 TEXT NOT NULL UNIQUE,

campo3 INTEGER,

FOREIGN KEY (campo3) REFERENCES tabla2(campo1)

);

CREATE TABLE tabla2 (

campo1 INTEGER PRIMARY KEY AUTOINCREMENT,

campo2 TEXT UNIQUE,

campo3 TEXT NOT NULL,

);

# Declarar acciones de clave externa:

# Las acciones se utilizan para controlar

# qué hacer en caso de borrado o actualización

# de una clave externa.

FOREIGN KEY (clave_externa)

REFERENCES tabla_padre(clave_padre)

ON UPDATE acción

ON DELETE acción;

# Ejemplo:

CREATE TABLE tabla1 (

campo1 INTEGER PRIMARY KEY AUTOINCREMENT,

campo2 TEXT UNIQUE,

campo3 TEXT NOT NULL,

campo4 INTEGER,

FOREIGN KEY (campo4) REFERENCES tabla2(campo1) ON DELETE CASCADE ON

UPDATE NO ACTION

);

# Acciones:

# SET NULL. Cuando existen cambios en clave

# primaria, eliminación o actualización,

# las claves secundarias (externas) correspondientes

# de todas las filas se establecen con el valor NULL.

# SET DEFAULT. En este caso las claves externas

# se establecen con el valor por defecto definido

# en el momento de la creación de la tabla.

# RESTRICT. Establece el comportamiento por defecto,

# aplicando las restricciones de clave externa.

# CASCADE. Los cambios en la clave primaria se

# propagarán a todas las claves secundarias que

# dependan de ella.

# NO ACTION. No se realizará ninguna acción.

# Verificar si SQLite soporta restricciones

# de clave externa (Las restricciones de clave

# externa son soportadas a partir de la versión 3.6.19)

# Comprobar si están activas las restricciones:

# PRAGMA foreign_keys;

# Desactivar restricciones:

# PRAGMA foreign_keys=OFF;

# Activar restricciones de clave externa:

# PRAGMA foreign_keys=ON;

Cambiar la estructura de una tabla (ALTER TABLE)

# Renombrar una tabla:

ALTER TABLE tabla1 RENAME TO tabla1_anterior;

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 8/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3
# Añadir campo o columna:

ALTER TABLE tabla1 ADD COLUMN campo4 INTEGER;

# La nueva columna no puede ser UNIQUE o

# PRIMARY KEY. Si la nueva columna tiene una

# restricción NOT NULL es necesario especificar

# un valor predeterminado que no sea el

# valor NULL:

CREATE TABLE tabla1 (... campo4 INTEGER DEFAULT 1, ...);

Borrar una tabla

# Borrar una tabla:

DROP TABLE tabla1;

# Si hay relaciones con otras tablas y las

# restricciones están activas no será posible

# borrar la tabla.

# Aparecerá el mensaje: "constraint failed"

# Se podría borrar desactivando antes las

# restricciones. Después, el campo que relacionaba

# la tabla maestra con la auxiliar se puede

# establecer con el valor NULL:

PRAGMA foreign_keys = OFF;

DROP TABLE tabla_auxiliar;

UPDATE tabla_maestra SET campo4 = NULL;

PRAGMA foreign_keys = ON;

Operaciones con Vistas

Una vista es una consulta que se presenta como una tabla (virtual) que se construye a partir de
los datos de una o más tablas relacionadas de una base de datos.

Las vistas tienen la misma estructura que una tabla normal (filas y columnas) con la diferencia de
que sólo almacenan la definición de una consulta, no los datos.

# A partir de las siguientes tablas:

tabla1: nombre, codigo

tabla2: codigo, descripcion

# Crear vista vinculando registros de ambas

# tablas por el campo "codigo"

CREATE VIEW IF NOT EXISTS nombre_vista AS

SELECT descripcion, tabla1.codigo, tabla2.codigo, nombre

FROM tabla1

INNER JOIN tabla2 ON tabla2.codigo = tabla1.codigo;

# Consultar todos los registros de una vista:

SELECT * FROM nombre_vista;

# Consultar algunos registros de una vista:

SELECT * FROM nombre_vista WHERE nombre = "Carlos";

# Borrar vista:

DROP VIEW IF EXISTS nombre_vista;

Operaciones con Índices

Un índice permite consultar datos con más rapidez, acelerar la operación de ordenación y hacer
cumplir las restricciones únicas.

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 9/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3

Cada índice debe estar asociado con una tabla específica. Un índice se compone de una o más
columnas pero todas las columnas de un índice deben estar en la misma tabla. Una tabla puede
tener varios índices.

# Crear índices:

CREATE INDEX nombre_indice ON tabla1(campo_indice);

# Crear índices con claves únicas:

# La opción UNIQUE es opcional y sirve para

# asegurarse de que el valor de la columna

# es único:

CREATE UNIQUE INDEX nombre_indice ON tabla1(campo2);

# Comprobar si se está utilizando el índice:

EXPLAIN QUERY PLAN SELECT * FROM tabla1 WHERE campo2 = "[email protected]";

# Crear indice multicampo:

CREATE INDEX indice1 ON tabla1 (campo2, campo3);

# Si se consulta la tabla por alguno o

# los dos campos, con la cláusula WHERE,

# se utilizará el índice de múltiples campos.

# Borrar índice:

DROP INDEX IF EXISTS indice1;

# Índices basados en expresiones:

# Además de los índices normales SQLite

# permite construir un índice basado en

# expresiones en las cuales se utilizan los

# campos de una tabla. Estos índice se usan

# para mejorar el rendimiento de las consultas.

# Crear índice con la longitud de un campo:

CREATE INDEX indice_longitud ON tabla1(LENGTH(campo2));

# Crear índice con el resultado de multiplicar dos campos:

CREATE INDEX indice_total ON tabla1(campo3*campo4);

Operaciones con Triggers

Un trigger es un objeto de base de datos que se ejecuta automáticamente cuando se realiza

una operación (INSERT, UPDATE o DELETE) en una tabla.

# Sintaxis:

CREATE TRIGGER [IF NOT EXISTS] nombre_trigger

[BEFORE|AFTER|INSTEAD OF] [INSERT|UPDATE|DELETE]

ON nombre_tabla

[WHEN condition]

BEGIN

declaraciones;

END;

# Crear trigger para validar un campo

# antes de insertar un registro:

CREATE TRIGGER validar_dato BEFORE INSERT ON tabla1

BEGIN

SELECT

CASE

WHEN NEW.campo4 NOT LIKE '%_@__%.__%' THEN

RAISE (ABORT,'Dirección de correo incorrecta')

END;

END;

# Crear Trigger para insertar un registro

# en una tabla cuando se modifiquen datos en otra:

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 10/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3
CREATE TRIGGER guardar_cambios AFTER UPDATE ON tabla1

WHEN old.campo1 <> new.campo1 OR old.campo2 <> new.campo2

BEGIN

INSERT INTO tabla_cambios ( old_campo1, new_campo1, old_campo2,

new_campo2, tipo_operacion, fecha_cambio )

VALUES

( old.campo1, new.campo1, old.campo2, new.campo2, 'UPDATE',

DATETIME('NOW'));

END;

# Borrar Trigger:

DROP TRIGGER IF EXISTS guardar_cambios;

Optimizar una base de datos

Las siguientes operaciones permiten optimizar una base de datos:

# Optimizar la base de datos abierta:

VACUUM;

# Optimización automática completa:

PRAGMA auto_vacuum = FULL;

# Optimización automática incremental:

PRAGMA auto_vacuum = INCREMENTAL;

# Desactivar modo automático de optimización:

PRAGMA auto_vacuum = NONE;

Garantizar fiabilidad en las transacciones

Las transacciones se utilizan para garantizar la integridad y fiabilidad de los datos.

Cuando se
inicia una transacción esta permanece abierta hasta que se confirma o deshace una operación
de forma explícita. Después de iniciar la transacción se ejecutan los comandos SQL para
seleccionar o actualizar datos. Finalmente, se confirman los cambios con la sentencia COMMIT
o COMMIT TRANSACTION; o se deshacen con ROLLBACK o ROLLBACK TRANSACTION

# Iniciar transacción:

BEGIN TRANSACTION;

# Confirmar transacción:

COMMIT;

# Deshacer transacción:

ROLLBACK;

# Ejemplo:

BEGIN TRANSACTION;

UPDATE tabla1 SET campo1 = 0 WHERE campo2 = 41;

UPDATE tabla1 SET campo1 = 0 WHERE campo2 = 28;

INSERT INTO tabla1 (campo1, campo2, campo3) VALUES (10, 31, 41);

INSERT INTO tabla1 (campo1, campo2, campo3) VALUES (50, 90, 28);

COMMIT;

Exportar una consulta (SELECT)

# Exportar una consulta en columnas de

# longitud fija:

.output tabla1.txt

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 11/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3
SELECT * FROM vista_tabla1;

.mode column

# Exportar consulta en formato CSV

# (valores separados por comas):

.output tabla1.csv

SELECT * FROM tabla1 ORDER BY campo2 LIMIT 10;

.separator ,

.mode csv

Salvar y restaurar una base de datos

# Salvar comandos SQL y datos necesarios

# para reconstruir una base de datos:

sqlite3 basedatos.bd

.output basedatos.sql

.dump

# Restaurar base de datos:

sqlite3 nueva_basedatos.bd

.read basedatos.sql

# Salvar comandos SQL y datos necesarios

# para reconstruir una tabla:

sqlite3 basedatos.bd

.output tabla1.sql

.dump tabla1

# Salvar estructura de las tablas,

# índices y vistas (sin datos):

.output basedatos_estructura.sql

.schema

# Salvar comandos SQL para insertar datos:

.mode insert

.output tabla1_datos.sql

SELECT * FROM tabla1;

Importar y exportar datos en formato CSV

# Importar datos a una tabla existente:

.mode csv

.import tabla1.csv tabla1

# Para borrar los datos de la tabla:

DELETE FROM tabla1;

# Importar datos a una tabla creando

# previamente la tabla:

DROP TABLE IF EXISTS tabla1;

CREATE TABLE tabla1 (

campo1 INTEGER PRIMARY KEY AUTOINCREMENT,

campo2 TEXT UNIQUE,

campo3 TEXT NOT NULL);

.mode csv

.import tabla1.csv tabla1

# Exportar datos con cabecera:

sqlite3 basedatos.db

.output tabla1_datos_cabecera.csv

.headers on

.mode csv

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 12/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3
SELECT * FROM tabla1;

# Exportar datos con cabecera desde la línea de comandos:

sqlite3 -header -csv basedatos.db "SELECT * FROM tabla1;" > tabla1.csv

Caso práctico 1: operaciones con base de datos (redlocal.db)

En este caso práctico se crea una base de datos con cuatro tablas en las que se declaran claves
primarias y externas. También, se crean índices y vistas y se realizan operaciones con registros
habilitando las restricciones de clave externa para garantizar la integridad de los datos.

# Iniciar sqlite3:

sqlite3

# Crear base de datos:

.open redlocal.db

# Crear tablas:

CREATE TABLE equipos (

id_equipo INTEGER PRIMARY KEY AUTOINCREMENT,

cta_equipo TEXT NOT NULL UNIQUE,

id_usu INTEGER,

alta TEXT NOT NULL,

FOREIGN KEY (id_usu) REFERENCES usuarios(id_usu)

);

CREATE TABLE usuarios (

id_usu INTEGER PRIMARY KEY AUTOINCREMENT,

cta_usu TEXT UNIQUE,

nombre TEXT NOT NULL,

id_dpte INTEGER,

ecorreo TEXT NOT NULL,

FOREIGN KEY (id_dpte) REFERENCES dptes(id_dpte)

);

CREATE TABLE dptes (

id_dpte INTEGER PRIMARY KEY AUTOINCREMENT,

denom TEXT NOT NULL UNIQUE

);

CREATE TABLE accesos (

id_acceso INTEGER PRIMARY KEY AUTOINCREMENT,

id_equipo INTEGER,

id_usu INTEGER,

ult_acceso TEXT NOT NULL,

FOREIGN KEY (id_equipo) REFERENCES equipos(id_equipo),

FOREIGN KEY (id_usu) REFERENCES usuarios(id_usu)

);

# Habilitar las restricciones de clave externa:

PRAGMA foreign_keys=ON;

# Crear índices:

CREATE UNIQUE INDEX ind_equipos ON equipos(cta_equipo);

CREATE UNIQUE INDEX ind_usuarios ON usuarios(cta_usu);

CREATE UNIQUE INDEX ind_dptes ON dptes(denom);

# Listar esquema de una tabla e índices:

.schema dptes

# Listar índices

.indices

# Insertar algunos registros:

INSERT INTO dptes (denom) VALUES ('Tenis'), ('Baloncesto'),

('Badminton'), ('Taekwondo');

INSERT INTO usuarios (id_usu, cta_usu, nombre, id_dpte, ecorreo)

VALUES (1, "rnadal", "Rafa Nadal", 1, "[email protected]");

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 13/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3
INSERT INTO usuarios (cta_usu, nombre, id_dpto, ecorreo)

VALUES ("pgasol", "Pau Gasol", 2, "[email protected]");

INSERT INTO usuarios (cta_usu, nombre, id_dpte, ecorreo)

VALUES ("cmartin", "Carolina Martin", 3, "[email protected]");

INSERT INTO usuarios (cta_usu, nombre, id_dpte, ecorreo)

VALUES ("ecalvo", "Eva Calvo", 4, "[email protected]");

INSERT INTO usuarios (cta_usu, nombre, id_dpte, ecorreo)

VALUES ("mlopez", "Marc Lopez", 1, "[email protected]");

INSERT INTO equipos (cta_equipo, id_usu, alta)

VALUES ('PC01', 2, datetime('now', 'localtime'));

INSERT INTO equipos (cta_equipo, id_usu, alta)

VALUES ('PC02', 1, datetime('now', 'localtime'));

INSERT INTO equipos (cta_equipo, id_usu, alta)

VALUES ('PC03', 3, datetime('now', 'localtime'));

INSERT INTO accesos (id_equipo, id_usu, ult_acceso)

VALUES (1, 2, datetime('now', 'localtime'));

INSERT INTO accesos (id_equipo, id_usu, ult_acceso)

VALUES (2, 1, datetime('now', 'localtime'));

# Crear vistas

CREATE VIEW vista_equipos1 AS SELECT cta_equipo, alta,

nombre, ecorreo FROM equipos INNER JOIN usuarios

ON usuarios.id_usu = equipos.id_usu;

CREATE VIEW vista_equipos2 AS SELECT cta_equipo, alta,

nombre, ecorreo, denom FROM equipos INNER JOIN usuarios

ON usuarios.id_usu = equipos.id_usu INNER JOIN dptes

ON usuarios.id_dpte = dptes.id_dpte;

# Seleccionar registros de una vista:

SELECT * FROM vista_equipos1;

SELECT * FROM vista_equipos2;

# Listar tablas y vistas:

.tables

# Comprobar si una consulta utiliza un índice:

EXPLAIN QUERY PLAN SELECT * FROM usuarios WHERE cta_usu = "mlopez";

# 0|0|0|SEARCH TABLE usuarios USING INDEX ind_usuarios (cta_usu=?)

Caso práctico 2: operaciones con base de datos (contactos.db)

En este caso práctico se crea una base de datos con tres tablas en las que se declaran claves
primarias y externas. También, se crean índices y vistas y se realizan operaciones con registros
habilitando las restricciones de clave externa para garantizar la integridad de los datos.

También, se realizan operaciones sobre la base de datos para comprobar la acción "ON DELETE
CASCADE" utilizada en la declaración de las claves externas.

# Crear base de datos:

sqlite3

.open contactos.db

# Crear tablas con clave primaria:

CREATE TABLE contactos (

contacto_id integer PRIMARY KEY,

nombre text NOT NULL,

apellido text NOT NULL,

email text NOT NULL UNIQUE,

movil text NOT NULL UNIQUE

);

CREATE TABLE grupos (

grupo_id integer PRIMARY KEY,

nombre text NOT NULL

);

# Crear tabla con clave primaria formada por

# dos campos que son claves externas:

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 14/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3

CREATE TABLE contactos_grupos (

contacto_id integer,

grupo_id integer,

PRIMARY KEY (contacto_id, grupo_id),

FOREIGN KEY (contacto_id) REFERENCES contactos (contacto_id)

ON DELETE CASCADE ON UPDATE NO ACTION,

FOREIGN KEY (grupo_id) REFERENCES grupos (grupo_id)

ON DELETE CASCADE ON UPDATE NO ACTION

);

# Realizar operaciones sobre la base de

# datos para comprobar la acción

# "ON DELETE CASCADE" utilizada al declarar

# las claves externas:

# Insertar registros

INSERT INTO grupos (grupo_id, nombre) VALUES (1, "amigos");

INSERT INTO grupos (grupo_id, nombre) VALUES (2, "trabajo");

INSERT INTO grupos (grupo_id, nombre) VALUES (3, "asociacion");

INSERT INTO contactos (contacto_id, nombre, apellido, email, movil)

VALUES (1, "Luis", "Carranza", "[email protected]","123 234 345");

INSERT INTO contactos (contacto_id, nombre, apellido, email, movil)

VALUES (2, "Clara", "Campoamor", "[email protected]","455 555 655");

INSERT INTO contactos (contacto_id, nombre, apellido, email, movil)

VALUES (3, "Dolores", "Fuertes", "[email protected]","155 155 155");

INSERT INTO contactos_grupos (contacto_id, grupo_id) VALUES (1, 1);

INSERT INTO contactos_grupos (contacto_id, grupo_id) VALUES (2, 1);

INSERT INTO contactos_grupos (contacto_id, grupo_id) VALUES (1, 3);

INSERT INTO contactos_grupos (contacto_id, grupo_id) VALUES (3, 3);

INSERT INTO contactos_grupos (contacto_id, grupo_id) VALUES (1, 2);

INSERT INTO contactos_grupos (contacto_id, grupo_id) VALUES (2, 2);

INSERT INTO contactos_grupos (contacto_id, grupo_id) VALUES (3, 2);

# Borrar un registro de la tabla auxiliar

DELETE FROM grupos WHERE grupo_id = 3;

SELECT * FROM grupos;

# 1|amigos

# 2|trabajo

# Seleccionar todos los registros:

SELECT * FROM contactos_grupos;

# 1|1

# 2|1

# 1|2

# 2|2

# 3|2

# Todos los registros de la clave externa

# suprimida han sido borrados.

# Crear vista:

CREATE VIEW vista_contactos AS SELECT contactos.nombre AS nombrec,

apellido, email, grupos.nombre AS nombreg FROM contactos

INNER JOIN contactos_grupos ON

contactos.contacto_id = contactos_grupos.contacto_id INNER JOIN

grupos ON grupos.grupo_id = contactos_grupos.grupo_id;

# Consultar todos los registros de la vista:

SELECT * FROM vista_contactos;

# Luis|Carranza|[email protected]|amigos
# Clara|Campoamor|[email protected]|amigos

# Luis|Carranza|[email protected]|trabajo

# Clara|Campoamor|[email protected]|trabajo

# Dolores|Fuertes|[email protected]|trabajo

# Consultar todos los registros de los "amigos":

SELECT * FROM vista_contactos WHERE nombreg = "amigos";

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 15/16
15/3/22, 13:22 Python 3 para impacientes: Guía rápida de SQLite3
# Luis|Carranza|[email protected]|amigos
# Clara|Campoamor|[email protected]|amigos

Ir al inicio de la página actual

Inicio

Suscribirse a:
Entradas (Atom)

2014-2020 | Alejandro Suárez Lamadrid y Antonio Suárez Jiménez, Andalucía - España

. Tema Sencillo. Con la tecnología de Blogger.

https://python-para-impacientes.blogspot.com/p/blog-page_27.html 16/16
15/3/22, 13:09 Pandas Basics - Learn Python - Free Interactive Python Tutorial

Pandas Basics

Pandas Basics
Pandas DataFrames
Pandas es una herramienta de manipulación de datos de alto nivel desarrollada por Wes McKinney. Es construido con el paquete
Numpy y su estructura de datos clave es llamada el DataFrame. El DataFrame te permite almacenar y manipular datos tabulados en filas
de observaciones y columnas de variables.

Hay varias maneras de crear un DataFrame. Una es usar un diccionario. Por ejemplo:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6ImRpY3QgPSB7XCJjb3VudHJ5XCI6IFtcIkJyYXppbFwiLCBcIlJ1c3NpYVwiLCBcIkluZGlhXCIsIFwiQ2hpbmFcIiwgXCJTb3V0aCBBZnJpY2FcIl0
Como puedes ver con el nuevo DataFrame brics , Pandas tiene asignada una clave para cada país como valores numéricos de 0 a 4. Si
deseas tener diferentes valores de índice, por ejemplo el código del país de dos letras, tambien puedes hacerlo facilmente.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiZGljdCA9IHtcImNvdW50cnlcIjogW1wiQnJhemlsXCIsIFwiUnVzc2lhXCIsIFwiSW5kaWFcIiwgXCJDaGluYVwiLCBcIlNvdXRo
Otra manera de crear un DataFRame es importando un archivo csv usando Pandas. Ahora, el csv cars.csv es almacenado y puede ser
importado usando pd.read_csv :

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiZiA9IG9wZW4oJ2NhcnMuY3N2JywgXCJ3XCIpXG5mLndyaXRlKFwiXCJcIixjYXJzX3Blcl9jYXAsY291bnRyeSxkcml2ZXNfcm

Indexando DataFrames
Hay varias maneras de indexar un DataFrame de Pandas. Una de las más sencillas es usar la notación de corchetes.

En el ejemplo de debajo, puedes usar corchetes para seleccionar una columna del DataFrame cars . Puedes usar corchetes simples o
dobles. Los corchetes simples tienen salida a Pandas Series, mientras que los corchetes dobles tendrán salida a a Pandas DataFrame.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiZiA9IG9wZW4oJ2NhcnMuY3N2JywgXCJ3XCIpXG5mLndyaXRlKFwiXCJcIixjYXJzX3Blcl9jYXAsY291bnRyeSxkcml2ZXNfcm
Los corchetes también pueden usarse para acceder a observaciones (filas) desde un DataFrame. Por ejemplo:

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiZiA9IG9wZW4oJ2NhcnMuY3N2JywgXCJ3XCIpXG5mLndyaXRlKFwiXCJcIixjYXJzX3Blcl9jYXAsY291bnRyeSxkcml2ZXNfcm
También puedes usar loc e iloc para realizar casi cualquier operación de selección de datos. loc está basado en etiquetas, lo que
significa que puedes especificar filas y columnas basadas en sus etiquetas de filas y columnas. iloc es un índice basado en enteros, así
que tienes que especificar las filas y columnas con su índice entero tal y como hiciste en el ejercicio anterior.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInByZV9leGVyY2lzZV9jb2RlIjoiZiA9IG9wZW4oJ2NhcnMuY3N2JywgXCJ3XCIpXG5mLndyaXRlKFwiXCJcIixjYXJzX3Blcl9jYXAsY291bnRyeSxkcml2ZXNfcm

 Start Exercise

Copyright © learnpython.org. Read our Terms of Use and Privacy Policy

Code  Run
 Reset
Solution


Output Expected Output

https://www.learnpython.org/es/Pandas Basics 1/1

15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Buscar …

Menu


PYTHON

Tutorial de NLP con Python NLTK



(ejemplos simples)

Mokhtar Ebrahim
Publicada: septiembre 21, 2017 Última actualización: marzo 1, 2022

En esta publicación, hablaremos sobre el procesamiento del lenguaje

natural (NLP del inglés Natural Language Processing) usando Python.
Este tutorial de NLP usará la librería de Python NLTK. NLTK es una
popular librería de Python que se utiliza para NLP.

Entonces, ¿qué es NLP? y ¿cuáles son los beneficios de aprender NLP?

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 1/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Tabla de contenidos 

1. ¿Qúe es NLP?
2. Beneficios del NLP
3. Implementaciones del NLP
4. Librerías NLP
5. Instalar NLTK
6. Tokenizar un texto usando Python
7. Contar la frecuencia de palabras
8. Eliminar palabras de parada con NLTK
9. Tokenizar texto usando NLTK
 10. Tokenizar textos que no están en inglés
11. Obtener sinónimos de WordNet

12. Obtener antónimos de WordNet
 13. Derivación regresiva con NLTK (Word Stemming)
14. Derivación regresiva de palabras no inglesas
 15. Palabras lematizadoras usando WordNet (Lemmatize Words)
16. Diferencia de derivación regresiva y lematización

¿Qúe es NLP?

En pocas palabras, el procesamiento del lenguaje natural (NLP) consiste

en desarrollar aplicaciones y servicios que puedan comprender los
idiomas humanos.

Estamos hablando de ejemplos prácticos de procesamiento del lenguaje

natural (NLP), como el reconocimiento de voz, la traducción del habla, la
comprensión de oraciones completas, la comprensión de sinónimos de
palabras coincidentes y la escritura de oraciones y párrafos completos
gramaticalmente correctos.

Esto no es todo, puedes pensar en las implementaciones industriales

sobre estas ideas y sus beneficios.

 
https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 2/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Beneficios del NLP

Como todos ya sabes sabes, hay millones de gigabytes diarios generados

por blogs, sitios web sociales y páginas web.

Hay muchas empresas que reúnen todos estos datos para comprender a
los usuarios y sus pasiones y dar estos informes a las empresas para
ajustar sus planes.

Estos datos podrían mostrar que la gente de Brasil está contenta con el

producto A, que podría ser una película o cualquier cosa, mientras que la
 gente de EE. UU. está contenta con el producto B. Y esto podría ser
instantáneo (resultado en tiempo real). Al igual que los motores de

búsqueda, dan los resultados adecuados a las personas adecuadas en el


momento adecuado.

Sabes ademas que los motores de búsqueda no son la única

implementación del NLP; hay muchas implementaciones increíbles por
ahí.

Implementaciones del NLP

Estas son algunas de las implementaciones exitosas del procesamiento

de lenguaje natural (NLP):

Motores de búsqueda como Google, Yahoo, etc. El motor de

búsqueda de Google entiende que eres un técnico, por lo que te
muestra resultados relacionados a ti.

Los feeds de los sitios web sociales como la fuente de noticias de

Facebook. El algoritmo de feed de noticias entiende tus intereses
mediante el procesamiento de lenguaje natural y muestra anuncios y

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 3/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

publicaciones relacionadas con mayor probabilidad que otras

publicaciones.

Motores de voz como Apple Siri.

Filtros de spam como filtros de spam de Google. No se trata solo del

filtro de spam habitual, ahora los filtros de spam entienden qué hay
dentro del contenido del correo electrónico y ver si es un correo no
deseado o no.

 


 Librerías NLP
 Hay muchas librerías de NLP de código abierto y éstas son algunas de
ellas:


Natural language toolkit (NLTK).

Apache OpenNLP.

Stanford NLP suite.

Gate NLP library.

Natural language toolkit (NLTK) es la biblioteca más popular para el

procesamiento del lenguaje natural (NLP) que fue escrita en Python y
tiene una gran comunidad detrás.

NLTK también es muy fácil de aprender; en realidad, es la biblioteca de

procesamiento de lenguaje natural (NLP) más fácil que usará.

En este tutorial de NLP, usaremos la biblioteca Python NLTK.

Antes de comenzar a instalar NLTK, supongo que conoces algunos

aspectos básicos de Python para comenzar.

 
https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 4/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Instalar NLTK

Si está usando Windows o Linux o Mac, puede instalar NLTK usando pip:

$ pip install nltk

Puedes usar NLTK en Python 2.7, 3.4 y 3.5 en el momento de escribir esta
publicación.

Alternativamente, puedes instalarlo desde la fuente desde este tar.

Para verificar si la librería NLTK se ha instalado correctamente, puedes

abrir la terminal de Python y escribir lo siguiente:


Import nltk

Si todo va bien, eso significa que has instalado correctamente la librería

NLTK.

Una vez que instalada la librería NLTK, debes instalar los paquetes NLTK
ejecutando el siguiente código:

import nltk

nltk.download()

Esto mostrará el descargador NLTK para elegir qué paquetes deben

instalarse.

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 5/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Puedes instalar todos los paquetes ya que sus tamaños son pequeños
por lo que no habrá problema. Ahora comencemos el show.

Tokenizar un texto usando Python

Primero, tomaremos el contenido de una página web y luego

analizaremos el texto para ver de qué se trata la página.

Utilizaremos el módulo urllib para rastrear la página web:

import urllib.request

response = urllib.request.urlopen('http://php.net/')

html = response.read()

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 6/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

print (html)

Como puedes ver en la salida impresa, el resultado contiene muchas

etiquetas HTML que deben limpiarse.puedes ver en la salida impresa, el
resultado contiene muchas etiquetas HTML que deben limpiarse.

Podemos usar BeautifulSoup para limpiar el texto capturado de esta

manera:

from bs4 import BeautifulSoup

import urllib.request

 response = urllib.request.urlopen('http://php.net/')

html = response.read()

soup = BeautifulSoup(html,"html5lib")

text = soup.get_text(strip=True)

print (text)

Ahora tenemos el texto limpio de la página web rastreada.

Impresionante, ¿verdad?

Finalmente, convirtamos ese texto en tokens dividiendo el texto de esta

manera:

from bs4 import BeautifulSoup

import urllib.request

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 7/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

response = urllib.request.urlopen('http://php.net/')

html = response.read()

soup = BeautifulSoup(html,"html5lib")

text = soup.get_text(strip=True)

tokens = [t for t in text.split()]

print (tokens)

 


Contar la frecuencia de palabras


El texto está mucho mejor ahora. Calculemos la distribución de

frecuencia de esos tokens usando Python NLTK.

Hay una función en NLTK llamada FreqDist() hace el trabajo:

from bs4 import BeautifulSoup

import urllib.request

import nltk

response = urllib.request.urlopen('http://php.net/')

html = response.read()

soup = BeautifulSoup(html,"html5lib")

text = soup.get_text(strip=True)

tokens = [t for t in text.split()]

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 8/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

freq = nltk.FreqDist(tokens)

for key,val in freq.items():

print (str(key) + ':' + str(val))

Si buscas el resultado, verás que el token más frecuente es PHP.

Puedes elaborar un gráfico para esos tokens usando una función como
 esta:


freq.plot(20, cumulative=False)


https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 9/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Desde el gráfico, puedes estar seguro de que este artículo está hablando
de PHP.

¡Estupendo!

Hay algunas palabras como The, Of, a, an, y así sucesivamente. Estas
palabras son palabras de parada (stop words).

En general, se deben eliminar las palabras de parada para evitar que

afecten a nuestros resultados.

 


 Eliminar palabras de parada con NLTK


NLTK contiene listas de palabras prohibidas para la mayoría de los
idiomas. Para obtener las palabras de parada en inglés, puedes usar este
código:

from nltk.corpus import stopwords

stopwords.words('english')

Ahora, modifiquemos nuestro código y limpiemos los tokens antes de

trazar el gráfico.

Primero, haremos una copia de la lista, luego iteraremos sobre los tokens
y eliminaremos las palabras de parada:

clean_tokens = tokens[:]

sr = stopwords.words('english')

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 10/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

for token in tokens:

if token in stopwords.words('english'):

clean_tokens.remove(token)

Puede revisar las funciones de la lista de Python para saber cómo

procesar listas

Así que el código final debería ser así:



from bs4 import BeautifulSoup


import urllib.request

import nltk

from nltk.corpus import stopwords

response = urllib.request.urlopen('http://php.net/')

html = response.read()

soup = BeautifulSoup(html,"html5lib")

text = soup.get_text(strip=True)

tokens = [t for t in text.split()]

clean_tokens = tokens[:]

sr = stopwords.words('english')

for token in tokens:

if token in stopwords.words('english'):

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 11/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

clean_tokens.remove(token)

freq = nltk.FreqDist(clean_tokens)

for key,val in freq.items():

print (str(key) + ':' + str(val))

Si revisas el gráfico ahora, verás es mejor que antes ya que no hay

 palabras de parada en el conteo.


freq.plot(20,cumulative=False)


https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 12/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Tokenizar texto usando NLTK

Vimos cómo dividir el texto en tokens utilizando la función split; ahora

veremos cómo convertir el texto en tokens con NLTK.

Tokenizar el texto es importante ya que el texto no se puede procesar sin

tokenizarlo. El proceso de tokenización significa dividir partes más
grandes en partes pequeñas.

Puedes convertir párrafos en oraciones y confeccionar frases en palabras


según tus necesidades. NLTK contiene un tokenizador de frase y un
 tokenizador de palabra.

 Supongamos que tenemos un texto de muestra como el siguiente:


Hello Adam, how are you? I hope everything is going well. Today

Para tokenizar este texto en oraciones, usaremos sent_tokenize():

from nltk.tokenize import sent_tokenize

mytext = "Hello Adam, how are you? I hope everything is going w

print(sent_tokenize(mytext))

La salida es la siguiente:

['Hello Adam, how are you?', 'I hope everything is going well.'

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 13/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Puede decir que es es un trabajo fácil y no necesito usar el tokenizador

NLTK, pues, puedo dividir oraciones usando expresiones regulares ya que
cada oración es precedida por punto y espacio.

Bueno, mira el siguiente texto:

Hello Mr. Adam, how are you? I hope everything is going well. T

 Uh! La palabra Mr. es una palabra en sí misma. Bien, probemos NLTK:

from nltk.tokenize import sent_tokenize

mytext = "Hello Mr. Adam, how are you? I hope everything is goi


print(sent_tokenize(mytext))

The output looks like this:

['Hello Mr. Adam, how are you?', 'I hope everything is going we

¡Estupendo! Funciona como por encanto.

OK, intentemos con el tokenizador de palabras para ver cómo funcionará.

from nltk.tokenize import word_tokenize

mytext = "Hello Mr. Adam, how are you? I hope everything is goi

print(word_tokenize(mytext))

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 14/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

La salida es:

['Hello', 'Mr.', 'Adam', ',', 'how', 'are', 'you', '?', 'I', 'h

La palabra Mr. es una palabra como se esperaba.

NLTK usa PunktSentenceTokenizer, que es parte del módulo


nltk.tokenize.punkt.

Este tokenizer se entrenó bien para trabajar con muchos idiomas.


 


Tokenizar textos que no están en inglés

Para tokenizar otros idiomas, puedes especificar el idioma de esta

manera:

from nltk.tokenize import sent_tokenize

mytext = "Bonjour M. Adam, comment allez-vous? J'espère que tou

print(sent_tokenize(mytext,"french"))

El resultado se verá así:

['Bonjour M. Adam, comment allez-vous?', "J'espère que tout va

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 15/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Lo estamos haciendo bien.

Obtener sinónimos de WordNet

Si recuerdas, instalamos paquetes NLTK usando nltk.download(). Uno de

los paquetes fue WordNet.

WordNet es una base de datos creada para el procesamiento del lenguaje


natural. Incluye grupos de sinónimos y una breve definición.

Puedes obtener estas definiciones y ejemplos para una palabra dada

como esta:


from nltk.corpus import wordnet

syn = wordnet.synsets("pain")

print(syn[0].definition())

print(syn[0].examples())

El resultado es:

a symptom of some physical hurt or disorder

['the patient developed severe pain and distension']

WordNet incluye un montón de definiciones:

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 16/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

from nltk.corpus import wordnet

syn = wordnet.synsets("NLP")

print(syn[0].definition())

syn = wordnet.synsets("Python")

print(syn[0].definition())


El resultado es:


 the branch of information science that deals with natural langu

 large Old World boas

Puedes usar WordNet para obtener palabras como esta:

from nltk.corpus import wordnet

synonyms = []

for syn in wordnet.synsets('Computer'):

for lemma in syn.lemmas():

synonyms.append(lemma.name())

print(synonyms)

El resultado es:

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 17/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

['computer', 'computing_machine', 'computing_device', 'data_pro

¡Buenísimo!

Obtener antónimos de WordNet


Puedes obtener los antónimos de las palabras de la misma manera.

Antes de agregarlos a la matriz, todo lo que tienes que hacer es verificar


si cada lema es un antónimo o no.


from nltk.corpus import wordnet

antonyms = []

for syn in wordnet.synsets("small"):

for l in syn.lemmas():

if l.antonyms():

antonyms.append(l.antonyms()[0].name())

print(antonyms)

El resultado es:

['large', 'big', 'big']

Este es el poder de NLTK en el procesamiento del lenguaje natural.

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 18/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Derivación regresiva con NLTK (Word

Stemming)

La derivación regresiva significa eliminar afijos de las palabras y

encontrar la palabra raíz. Ej: La raíz de la palabra trabajando = > trabajo.

Los motores de búsqueda utilizan esta técnica al indexar páginas, puesto

 que muchas personas escriben versiones diferentes para la misma


palabra y todas derivan de la palabra raíz.

 Existen muchos algoritmos para la derivación regresiva, pero el algoritmo

más utilizado es el algoritmo Porter de derivación regresiva.


NLTK tiene una clase llamada PorterStemmer que usa el algoritmo de

derivación regresiva Porter.

from nltk.stem import PorterStemmer

stemmer = PorterStemmer()

print(stemmer.stem('working'))

El resultado es:

work

Bastante claro.

Hay algunos otros algoritmos de derivación regresiva como el algoritmo

de derivación regresiva de Lancaster.
https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 19/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

La salida de este algoritmo muestra resultados un poco diferentes para

pocas palabras. Puedes probar ambos para ver el resultado.

Derivación regresiva de palabras no inglesas

SnowballStemmer contiene 13 idiomas además del inglés.

Los idiomas admitidos son:


from nltk.stem import SnowballStemmer


print(SnowballStemmer.languages)


'danish', 'dutch', 'english', 'finnish', 'french', 'german', 'h

Puedes usar la función stem de la clase SnowballStemmer para derivar

palabras no inglesas:

from nltk.stem import SnowballStemmer

french_stemmer = SnowballStemmer('french')

print(french_stemmer.stem("French word"))

Los franceses pueden contarnos sobre los resultados :).

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 20/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

Palabras lematizadoras usando WordNet

(Lemmatize Words)

Lematizar palabras es similar a la derivación regresiva; pero, la diferencia

es el que la lematización es el mundo real.

A diferencia de la derivación regresiva, cuando intentas derivar algunas

palabras, dará como resultado algo como esto:


from nltk.stem import PorterStemmer


stemmer = PorterStemmer()

print(stemmer.stem('increases'))


El resultado es:

increas

Ahora, si tratamos de lematizar la misma palabra usando NLTK WordNet,

el resultado es el correcto:

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()

print(lemmatizer.lemmatize('increases'))

El resultado es:

increase
https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 21/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

El resultado puede terminar con un sinónimo o una palabra diferente,

pero con el mismo significado.

A veces, si tratas de lematizar una palabra como la palabra playing,

terminarás con la misma palabra.

Esto se debe a que la parte del habla predeterminada son sustantivos.

Para obtener verbos, debes especificar así:

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()

 print(lemmatizer.lemmatize('playing', pos="v"))

El resultado es:

play

En realidad, este es un muy buen nivel de compresión de texto, terminas

con una compresión del 50% al 60%.

El resultado podría ser un verbo, sustantivo, adjetivo o adverbio:

from nltk.stem import WordNetLemmatizer

lemmatizer = WordNetLemmatizer()

print(lemmatizer.lemmatize('playing', pos="v"))

print(lemmatizer.lemmatize('playing', pos="n"))

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 22/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

print(lemmatizer.lemmatize('playing', pos="a"))

print(lemmatizer.lemmatize('playing', pos="r"))

El resultado es:

play

playing


playing

playing


 

Diferencia de derivación regresiva y

lematización

Bien, vamos a intentar a derivar y lematizar algunas palabras:

from nltk.stem import WordNetLemmatizer

from nltk.stem import PorterStemmer

stemmer = PorterStemmer()

lemmatizer = WordNetLemmatizer()

print(stemmer.stem('stones'))

print(stemmer.stem('speaking'))

print(stemmer.stem('bedroom'))

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 23/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

print(stemmer.stem('jokes'))

print(stemmer.stem('lisa'))

print(stemmer.stem('purple'))

print('----------------------')

print(lemmatizer.lemmatize('stones'))

print(lemmatizer.lemmatize('speaking'))

print(lemmatizer.lemmatize('bedroom'))

print(lemmatizer.lemmatize('jokes'))

 print(lemmatizer.lemmatize('lisa'))

print(lemmatizer.lemmatize('purple'))

El resultado es:

stone

speak

bedroom

joke

lisa

purpl

----------------------

stone

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 24/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

speaking

bedroom

joke

lisa

purple


La derivación funciona con palabras sin conocer su contexto y es por eso
 que la raíz tiene una precisión menor, pero, es más rápida que la
lematización.



En mi opinión, la lematización es mejor que la derivación. Word
lemmatizing devuelve una palabra real, incluso si no es la misma palabra,
podría ser un sinónimo, pero al menos es una palabra real.

A veces no te importa este nivel de precisión y todo lo que necesitas es

velocidad, en este caso, la derivación es mejor.

Todos los pasos que discutimos en este tutorial de NLP fueron

preprocesamiento de texto. En publicaciones futuras, discutiremos el
análisis de texto usando Python NLTK.

Hice todo lo posible para que el artículo sea lo más sencillo y simple
posible. Espero que le sea útil.

Sigue regresando. Gracias.

 Share on Facebook  Tweet on Twitter    

Mokhtar Ebrahim
Fundadora de LikeGeeks. Estoy trabajando como administrador de sistemas Linux
desde 2010. Soy responsable de mantener, proteger y solucionar problemas de

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 25/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

servidores Linux para múltiples clientes de todo el mundo. Me

encanta escribir guiones de shell y Python para automatizar mi
trabajo.

4 THOUGHTS ON “TUTORIAL DE NLP CON PYTHON NLTK


(EJEMPLOS SIMPLES)”

Pablo dice:
2018-11-03 a las 3:37 am

Hola Te funciona bien la librería en español? Simule tu código y no me
 funciona

from nltk.stem import PorterStemmer

stemmer = PorterStemmer()

print(stemmer.stem(‘trabajando’))

gracias.

Responder

Mokhtar Ebrahim dice:

2018-11-04 a las 3:42 pm

No revisé el texto en español.

Pruébalo y cuéntanos los resultados.

Gracias,

Responder

Ramón UCI dice:

2018-11-10 a las 3:58 am

En español no funciona.

Responder

Mokhtar Ebrahim dice:

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 26/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

2018-11-10 a las 10:37 am

Quizás deberíamos buscar una alternativa.

Responder

DEJA UNA RESPUESTA

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están

marcados con *

Comentario *

Nombre * Correo electrónico *

Respuestas a mis comentarios Notify me of followup comments via e-mail. You

can also subscribe without commenting.

Publicar el comentario

Email

Suscribir

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 27/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

ESTE ES MI LIBRO PUBLICADO

ANUNCIOS

ANUNCIOS

ÚLTIMAS PUBLICACIONES
Algoritmo Depth First Search en Python (múltiples ejemplos)

Tutorial de la matrix de correlacion de Python

Tutorial para NumPy where (Con ejemplos)

Salir/Terminar scripts en Python (Ejemplos simples)

20+ Ejemplos de multilplicación de matrices en NumPy

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 28/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks
20+ Ejemplos de multilplicación de matrices en NumPy

Cifrado Cesar en Python (Tutorial de Cifrado de Texto)

Tutorial de loadtxt de NumPy( cargar datos de los archivos)

20+ ejemplos para aplanar listas en Python

ANUNCIOS

ANUNCIOS



ARTÍCULOS RELACIONADOS

Algoritmo Depth First Search en Python (múltiples ejemplos)

Tutorial de la matrix de correlacion de Python

Tutorial para NumPy where (Con ejemplos)

Salir/Terminar scripts en Python (Ejemplos simples)

20+ Ejemplos de multilplicación de matrices en NumPy

Cifrado Cesar en Python (Tutorial de Cifrado de Texto)

Tutorial de loadtxt de NumPy( cargar datos de los archivos)

20+ ejemplos para aplanar listas en Python

ANUNCIOS

ANUNCIOS

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 29/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

ÚLTIMOS COMENTARIOS
Mokhtar Ebrahim en Moderna web scraping en Python (Beautiful Soup y Selenium)

Manuel en Moderna web scraping en Python (Beautiful Soup y Selenium)

Alexis en Algoritmo Depth First Search en Python (múltiples ejemplos)

Mokhtar Ebrahim en 31+ ejemplos para el comando sed de Linux en la

manipulación de texto

 Zayda en 31+ ejemplos para el comando sed de Linux en la manipulación de texto


ANUNCIOS

ANUNCIOS

ELEGIDO PARA TI
31+ ejemplos para el comando sed de Linux en la manipulación de texto

Ejemplos de la GUI de Python (Tutorial de Tkinter)

30 ejemplos para el comando Awk en el procesamiento de texto

Tutorial de Kivy – Construye aplicaciones con interfaces gráficas usando Python

Tutorial de Python SQLite3 (Programación de bases de datos)

Crea tu primer rastreador web con python usando scrapy

Tutorial de PyQt5- Ejemplos de programación con GUI de Python

Scripting de Bash en Linux Parte 3 – Parámetros y opciones

https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 30/31
15/3/22, 13:19 Tutorial De NLP Con Python NLTK (ejemplos Simples) - Like Geeks

ANUNCIOS

ANUNCIOS

 Ejemplos de TensorFlow – Definir y Moderna web scraping en Python (Beautiful

usar tensores Soup y Selenium) 

Aviso Legal
Política de privacidad
Acerca de
Contacto


    


https://likegeeks.com/es/tutorial-de-nlp-con-python-nltk/ 31/31
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

 

Aprende
Machine
Learning
en Español

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 1/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

 

PRÁCTICA

¿Comprar casa o Alquilar?

Naive Bayes usando Python
 August 23, 2018 by Na8

Hoy veremos un nuevo ejercicio práctico, intentando llevar los algoritmos de Machine
Learning a ejemplos claros y de la vida real, repasaremos la teoría del Teorema de
Bayes (video) de estadística para poder tomar una decisión muy importante: ¿me
conviene comprar casa ó alquilar?

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 2/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

 

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 3/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

 
Veamos si la Ciencia de Datos nos puede ayudar a resolver el
misterio… ¿Si alquilo estoy tirando el dinero a la basura? ó ¿Es
realmente conveniente pagar una hipoteca durante el
<<resto de mi vida>>?

Si bien tocaremos el tema livianamente -sin meternos en detalles como intereses de

hipotecas variable/fija, porcentajes, comisiones de bancos,etc- haremos un planteo
genérico para obtener resultados y tomar la mejor decisión dada nuestra condición
actual.

En artículos pasados vimos diversos algoritmos Supervisados del Aprendizaje

Automático que nos dejan clasificar datos y/o obtener predicciones o asistencia a la
toma de decisiones (árbol de decisión, regresión logística y lineal, red neuronal). Por
lo general esos algoritmos intentan minimizar algún tipo de coste iterando las
entradas y las salidas y ajustando internamente las “pendientes” ó “pesos” para hallar
una salida. Esta vez, el algoritmo que usaremos se basa completamente en teoría de
probabilidades  y obteniendo resultados estadísticos. ¿Será suficiente el Teorema
de Bayes para obtener buenas decisiones? Veamos!

¿Qué necesitaras para programar?

Para realizar este ejercicio, crearemos una Jupyter notebook con código Python y la
librería SkLearn muy utilizada en Data Science. Recomendamos utilizar la suite para
Python de Anaconda. Puedes leer este artículo donde muestro paso a paso como
instalar el ambiente de desarrollo. Podrás descargar los archivos de entrada csv o
visualizar la notebook online (al final de este artículo los enlaces).

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 4/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

Nuestros Datos de Entrada:

 
Importemos las librerías que usaremos y visualicemos la información que tenemos
de entrada:

Python
1 import pandas as pd
2 import numpy as np
3 import matplotlib.pyplot as plt
4 from matplotlib import colors
5 import seaborn as sb
6  
7 %matplotlib inline
8 plt.rcParams['figure.figsize'] = (16, 9)
9 plt.style.use('ggplot')
10  
11 from sklearn.model_selection import train_test_split
12 from sklearn.metrics import classification_report
13 from sklearn.metrics import confusion_matrix
14 from sklearn.naive_bayes import GaussianNB
15 from sklearn.feature_selection import SelectKBest

Y carguemos la info del archivo csv:

Python
1 dataframe = pd.read_csv(r"comprar_alquilar.csv")
2 dataframe.head(10)

Las columnas que tenemos son:

ingresos: los ingresos de la familia mensual

gastos comunes: pagos de luz, agua, gas, etc mensual
Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 5/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

pago coche: si se está pagando cuota por uno o más coches, y los gastos en
combustible, etc al mes.
 gastos_otros: compra en supermercado y lo necesario para vivir al mes 
ahorros: suma de ahorros dispuestos a usar para la compra de la casa.
vivienda: precio de la vivienda que quiere comprar esa familia
estado civil:
0-soltero
1-casados
2-divorciados
hijos: cantidad de hijos menores y que no trabajan.
trabajo:
0-sin empleo 1-autónomo (freelance)
2-empleado
3-empresario
4-pareja: autónomos
5-pareja: empleados
6-pareja: autónomo y asalariado
7-pareja:empresario y autónomo
8-pareja: empresarios los dos o empresario y empleado
comprar: 0-No comprar 1-Comprar (esta será nuestra columna de salida, para
aprender)

Algunos supuestos para el problema formulado:

Está pensado en Euros pero podría ser cualquier otra moneda

No tiene en cuenta ubicación geográfica, cuando sabemos que dependerá
mucho los precios de los inmuebles de distintas zonas
Se supone una hipoteca fija a 30 años con interés de mercado “bajo”.

Con esta información, queremos que el algoritmo aprenda y que como resultado
podamos consultar nueva información y nos dé una decisión sobre comprar (1) o
alquilar (0) casa.
Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 6/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

El teorema de Bayes
 
El teorema de Bayes es una ecuación que describe la relación de
probabilidades condicionales de cantidades estadísticas. En clasificación
bayesiana estamos interesados en encontrar la probabilidad de que ocurra
una “clase” dadas unas características observadas (datos). Lo podemos escribir
como P( Clase | Datos). El teorema de Bayes nos dice cómo lo podemos
expresar en términos de cantidades que podemos calcular directamente:

Clase es una salida en particular, por ejemplo “comprar”

Datos son nuestras características, en nuestro caso los ingresos, gastos, hijos,
etc
P(Clase|Datos) se llama posterior (y es el resultado que queremos hallar)
P(Datos|Clase) se llama “verosimilitud” (en inglés likelihood)
P(Clase) se llama anterior (pues es una probabilidad que ya tenemos)
P(Datos) se llama probabilidad marginal

Si estamos tratando de elegir entre dos clases como en nuestro caso “comprar” ó
“alquilar”, entonces una manera de tomar la decisión es calcular la tasa de
probabilidades a posterior:

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 7/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

 

con esta maniobra, nos deshacemos del denominador de la ecuación anterior

P(Datos) el llamado “probabilidad marginal”.

Clasificador Gaussian Naive Bayes

Uno de los tipos de clasificadores más populares es el llamado en inglés Gaussian

Naive Bayes Classifier. NOTA:Hay otros clasificadores Bayesianos que no veremos en este artículo.
Veamos cómo es su fórmula para comprender este curioso nombre: aplicaremos 2
clases (comprar, alquilar) y tres características: ingresos, ahorros e hijos.

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 8/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

Posterior de comprar es lo que queremos hallar: P(comprar|datos).

 
Explicaremos los demá:

P(comprar) es la probabilidad que ya tenemos. Es sencillamente el número de

veces que se selecciona comprar =1 en nuestro conjunto de datos, dividido el
total de observaciones. En nuestro caso (luego lo veremos en Python) son
67/202
p(ingresos|comprar)p(ahorros|comprar)p(hijos|comprar) es la
verosimilitud. Los nombres Gaussian y Naive (ingenuo) del algoritmo vienen de
dos suposiciones:
1. asumimos que las características de la verosimilitud no estan
correlacionada entre ellas. Esto seria que los ingresos sean
independientes a la cantidad de hijos y de los ahorros. Como no es siempre
cierto y es una suposición ingenua es que aparece en el nombre “naive
bayes”
2. Asumimos que el valor de las características (ingresos, hijos, etc) tendrá una
distribución normal (gaussiana). Esto nos permite calcular cada parte
p(ingresos|comprar) usando la función de probabilidad de densidad
normal.
probabilidad marginal muchas veces es difícil de calcular, sin embargo, por la
ecuación que vimos más arriba, no la necesitaremos para obtener nuestro
valor a posterior. Esto simplifica los cálculos.

Bien!, Fin de teoría, sigamos con el ejercicio! Ahora toca visualizar nuestras entradas y
programar un poquito.

Visualización de Datos

Veamos qué cantidad de muestras de comprar o alquilar tenemos:

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 9/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

Python
1 print(dataframe.groupby('comprar').size())


comprar

0 135

1 67

dtype: int64

Esto son 67 que entradas en las que se recomienda comprar y 135 en las que no.

Hagamos un histograma de las características quitando la columna de resultados

(comprar):

Python
1 dataframe.drop(['comprar'], axis=1).hist()
2 plt.show()

Pareciera a grandes rasgos que la distribución de hijos e ingresos <<se parece>> un

poco a una distribución normal.

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 10/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

Preparar los datos de entrada

 
Vamos a hacer algo: procesemos algunas de estas columnas. Por ejemplo, podríamos
agrupar los diversos gastos. También crearemos una columna llamada financiar que
será la resta del precio de la vivienda con los ahorros de la familia.

Python
1 dataframe['gastos']=(dataframe['gastos_comunes']+dataframe['gastos_otros']+dataframe['pago_coche
2 dataframe['financiar']=dataframe['vivienda']-dataframe['ahorros']
3 dataframe.drop(['gastos_comunes','gastos_otros','pago_coche'], axis=1).head(10)

Y ahora veamos un resumen estadístico que nos brinda la librería Pandas con
describe():

1 reduced = dataframe.drop(['gastos_comunes','gastos_otros','pago_coche'], axis=1)

2 reduced.describe()

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 11/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

 

Feature Selection ó Selección de

Características

En este ejercicio haremos Feature Selection para mejorar nuestros resultados con
este algoritmo. En vez de utilizar las 11 columnas de datos de entrada que tenemos,
vamos a utilizar una Clase de SkLearn llamada SelectKBest con la que
seleccionaremos las 5 mejores características y usaremos sólo esas.

Python
1 X=dataframe.drop(['comprar'], axis=1)
2 y=dataframe['comprar']
3  
4 best=SelectKBest(k=5)
5 X_new = best.fit_transform(X, y)
6 X_new.shape
7 selected = best.get_support(indices=True)
8 print(X.columns[selected])

Index([‘ingresos’, ‘ahorros’, ‘hijos’, ‘trabajo’, ‘financiar’], dtype=’object’)

Bien, entonces usaremos 5 de las 11 características que teníamos. Las que “más
aportan” al momento de clasificar. Veamos qué grado de correlación tienen:

Python
1 used_features =X.columns[selected]
2  
3 colormap = plt.cm.viridis
4 plt.figure(figsize=(12,12))
5 plt.title('Pearson Correlation of Features', y=1.05, size=15)
6 sb.heatmap(dataframe[used_features].astype(float).corr(),linewidths=0.1,vmax=1.0, square=True, cm

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 12/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

 

Con esto comprobamos que en general están poco correlacionadas, sin embargo
también tenemos 2 valores de 0,7. Esperemos que el algoritmo sea lo
suficientemente “naive” para dar buenos resultados 😉

Otra alternativa para Feture Selection es utilizar Principal

Component Analysis (PCA) y hacer reducción de Dimensión

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 13/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

Crear el modelo Gaussian Naive Bayes


con SKLearn


Primero vamos a dividir nuestros datos de entrada en entrenamiento y test.

Python
1 # Split dataset in training and test datasets
2 X_train, X_test = train_test_split(dataframe, test_size=0.2, random_state=6)
3 y_train =X_train["comprar"]
4 y_test = X_test["comprar"]

Y creamos el modelo, lo ponemos a aprender con fit() y obtenemos predicciones

sobre nuestro conjunto de test.

Python
1 # Instantiate the classifier
2 gnb = GaussianNB()
3 # Train classifier
4 gnb.fit(
5     X_train[used_features].values,
6     y_train
7 )
8 y_pred = gnb.predict(X_test[used_features])
9  
10 print('Precisión en el set de Entrenamiento: {:.2f}'
11      .format(gnb.score(X_train[used_features], y_train)))
12 print('Precisión en el set de Test: {:.2f}'
13      .format(gnb.score(X_test[used_features], y_test)))

Precisión en el set de Entrenamiento: 0.87

Precisión en el set de Test: 0.90

Pues hemos obtenido un bonito 90% de aciertos en el conjunto de Test con nuestro
querido clasificador bayesiano. También puedes ver los resultados obtenidos
aplicando PCA en este otro artículo!

Probemos el modelo: ¿Comprar o

Alquilar?
Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 14/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

Ahora, hagamos 2 predicciones para probar nuestra máquina:


En un caso será una familia sin hijos con 2.000€ de ingresos que quiere
comprar una casa de 200.000€ y tiene sólo 5.000€ ahorrados.
El otro será una familia con 2 hijos con ingresos por 6.000€ al mes, 34.000 en
ahorros y consultan si comprar una casa de 320.000€.

Python
1 #                 ['ingresos', 'ahorros', 'hijos', 'trabajo', 'financiar']
2 print(gnb.predict([[2000,        5000,     0,       5,         200000],
3                    [6000,        34000,    2,       5,         320000] ]))
4 #Resultado esperado 0-Alquilar, 1-Comprar casa

[0 1]

Los resultados son los esperados, en el primer caso, recomienda Alquilar (0) y en el
segundo comprar la casa (1).

Conclusiones

A lo largo del artículo repasamos el teorema de Bayes y vimos un ejemplo para

aplicarlo en una toma de decisiones. Pero no olvidemos que en el proceso también
hicimos pre procesamiento de los datos, visualizaciones y Selección de
Características. Durante diversas charlas que tuve con profesionales del Data Science
en mi camino de aprendizaje sale un mismo mensaje que dice: “No es tan importante
el algoritmo a aplicar si no la obtención y pre procesamiento de los datos que se van
a utilizar”. A tenerlo en cuenta!

Naive Bayes como clasificador se utiliza mucho en NLP (Natural Language Processing)
tanto en el típico ejemplo de detectar “Spam” o no como en tareas más complejas
como reconocer un idioma o detectar la categoría apropiada de un artículo de texto.
También puede usarse para detección de intrusiones o anomalías en redes
informáticas y para diagnósticos médicos dados unos síntomas observados. Por
último veamos los pros y contras de utilizar Gaussian Naive Bayes: Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 15/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

Pros: Es rápido, simple de implementar, funciona bien con conjunto de datos

pequeños, va bien con muchas dimensiones (features) y llega a dar buenos
 resultados aún siendo “ingenuo” sin que se cumplan todas las condiciones de 
distribución necesarias en los datos.
Contras: Requiere quitar las dimensiones con correlación y para buenos
resultados las entradas deberían cumplir las 2 suposiciones de distribución
normal e independencia entre sí (muy difícil que sea así ó deberíamos hacer
transformaciones en lo datos de entrada).

Si les gustó el artículo les pido como favor si pueden ayudarme a difundir estas
páginas en vuestras redes sociales.

Además, como siempre, los invito a suscribirse al Blog ingresando una dirección de
email y recibirán una notificación cada 15 días (aprox.) con un nuevo artículo sobre
Aprende Machine Learning!.

Suscripción al Blog

Recibe el próximo artículo quincenal sobre Data Science y Machine Learning con
Python 

Email: Your email address here

ENVIAR

Más Recursos y descarga el Código

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 16/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

El código lo puedes ver en mi cuenta de Github ó …

lo puedes descargar desde aquí Jupyter Notebook Ejercicio Bayes Python Code
 Descarga el archivo csv de entrada comprar_alquilar.csv 
Otros artículos de interés sobre Bayes y Python en Inglés:

Naive Bayes Classifier from Scratch

Naive Bayes Classification with SkLearn
In Depth: Naive Bayes Classification
Bayesian Statistic for Data Science
Feature Selection
Comprende Principal Component Analysis

Comparte el artículo:

      

Relacionado

Perfiles y Roles para Proyectos IA, ¿Qué es Machine Learning? Una Principales Algoritmos usados en
Machine Learning y Data Science definición Machine Learning

Libros Relacionados

Algoritmos Aprendizaje Automático clasificación datos Definición

Ejercicio entrenar Jupyter Notebook Machine Learning Modelos
Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 17/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

predicción Python recursos Visualización

 

PROGRAMA UN COCHE ARDUINO CON INTELIGENCIA ARTIFICIAL

BREVE HISTORIA DE LAS REDES NEURONALES ARTIFICIALES

18 comments

Riki · August 24, 2018

Muchas gracias amigo

Reply

Na8 · August 24, 2018

Hola Riki, espero que el artículo haya sido de tu interés!,

saludos
Reply

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 18/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

 Michaell · August 24, 2018 

Muy interesante el tema!
Reply

Na8 · August 24, 2018

Hola Michaell, gracias por comentar! espero que sigas

visitando más artículos del blog. Saludos
Reply

Mariano Poledo · September 24, 2018

Muy bueno el artículo!, muchas gracias. Una consulta: como hago para
usar un archivo CVS para hacer las predicciones y que la predicción quede
guardada en el mismo archivo como un campo más?
Reply

Na8 · September 25, 2018

Hola Mariano, gracias por escribir!. Para guardar el archivo es

tan sencillo como agregar la columna en el dataframe de
Pandas que tengas creado y luego hacer
df.to_csv(“nombre_archivo.csv”).
Reply

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 19/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

 Michael Andrés · October 11, 2018 

Hola Juan Ignacio, estoy realizando mi primer proyecto de Machine
Learning y me estoy guiando por tu ejemplo y explicación, muchas gracias
por compartir todo el conocimiento que brindas en el blog, saludos.
Reply

Na8 · October 12, 2018

Hola Michael Andrés, muchas gracias por participar en el Blog

y espero que avances con tus proyectos!, seguimos en
contacto. Saludos
Reply

Gabriel Cornejo · June 13, 2019

Hola Juan Ignacio:

Esta es la segunda o tercera vez que visito tu página, y la verdad que me

parece fantástico la manera que explicas las cosas, Felicitaciones!!!
Me he suscrito y espero tener noticias tuyas de vez en cuando.

Un abrazo desde Santiago de Chile.

Reply

Na8 · June 19, 2019

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 20/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

Hola Gabriel, muchas gracias por escribir y me alegro que te

esté gustando! Saludos a Chile, de un argentino en España 😀
 Seguimos en contacto 
Reply

Alejandro martínez rivero · June 13, 2019

Hola Juan Ignacio, tu blog es simplemente fenomenal, me ayudo mucho en

mi aprendizaje de machine learning. soy de formación ingeniero de
organización industrial, cubano en brasil, pero estoy reinventandome y
haciendo algunas cosas en machine leraning. tu blog me sirvion de mucho!
Obrigado!!!!!
Reply

Na8 · June 19, 2019

Hola Alejandro, me alegro mucho que estés reinventandote!,

de eso se trata la vida (creo… con margen de error). Un saludo
grande y espero que sigas bien!
Reply

Hector · January 21, 2020

Hola Juan Ignacio,

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 21/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

Excelente articulo como siempre, tu pagina web me esta ayudando mucho

a aprender Machine Learning.
 
Tengo una pregunta con respecto al modelo. Al introducir los datos de un
cliente solvente [6100,33463,2,5,10000] con buenos ingresos, buenos
ahorros y poca cantidad a financiar el algoritmo me recomienda alquilar.
La verdad que el perfil del cliente no se parece demasiado al de los datos
de entrenamiento por lo que podria estar ahi el fallo. Me gustaria conocer
tu opinion acerca del resultado y como podriamos mejorarlo.

Un saludo,

Hector
Reply

Luis Ramirez · April 11, 2020

Hola Juan Ignacio, muchas gracias por estos artículos. Apenas empecé en
este mundo de la inteligencia artificial este año y me está encantando.
Estoy reforzando mucho los temas que estoy viendo con tus ejercicios.

Te hago una pregunta, cuando doy mi correo para recibir los artículos
quincenales, en el correo no me deja dar clic a la suscripción. Quisiera
saber si ya estoy en tus bases de datos para recibir los correos.

Muchas gracias
Reply
Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 22/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

 XXX · November 26, 2020 

Muchas gracias por el artículo!
Una pregunta, ¿es indiferente que las variables sean categóricas o
numéricas?
Has convertido en numérico el estado civil. Sí la forma de convertirlo en
numérico hubiese sido otra (ej: casado=8, soltero=23..) ¿el resultado habría
sido el mismo?

Repito: muchas gracias por el artículo

XXX
Reply

Na8 · December 5, 2020

En este caso que son sólo 3valores, puede que no afecte

demasiado, pero en general la transformación de categóricos
a numéricos es sumamente importante y sí que influye el
valor que se le asigne. Por eso surgen técnicas como one-hot
encoder, TargetEncoder ó binning.
Saludos y gracias
Reply

Sergio Lopez · September 16

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 23/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

muy bueno, me estoy leyendo todo el blog, y la verdad, aunque me guste

leer en ingles, al no ser nativo en ese idioma, poder aprender con estos
 blog en español me ha ayudado mucho a entender, la unica 
recomendacion, como usuario que entra todos los dias a tu blog, es que
coloque la caja de comentarios al principio y no al final de los comentarios,
es mas para una mejor experiencia de usuario, saludos desde Argentina.
Reply

Na8 · November 29

Hola, muchas gracias por leer el blog y por tu comentario!

Un saludo!
Reply

Leave a Reply

Visita nuestra Guía de Aprendizaje

Buscar

Search …

Contacto

Suscripción
Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 24/25
15/3/22, 13:13 ¿Comprar casa o Alquilar? Naive Bayes usando Python | Aprende Machine Learning

Recibe los artículos de Aprende Machine Learning en tu casilla de correo. Cada 15 días y sin
Spam!

Email: Your email address here 

ENVIAR

Proudly powered by WordPress | Theme: Eighties by Justin Kopepasah.

Privacidad - Términos

https://www.aprendemachinelearning.com/comprar-casa-o-alquilar-naive-bayes-usando-python/ 25/25
Introducción a las Redes
Neuronales
Ph.D Darwin Patiño Pérez
Octubre 2020
 Introducción a las Redes Neuronales

Contenidos
• Introducción a las neuronas
• Introducción a las redes neuronales artificiales (ANN)
• Introducción a algunos algoritmos de aprendizaje de
las ANNs
 Introducción a las Neuronas
• En nuestro sistema nervioso existen células
llamadas neuronas que son una unidad de
procesamiento que recibe un estimulo
eléctrico de otras neuronas principalmente a
través de su árbol dendrítico
• El estimulo eléctrico recibido al pasar de un
cierto umbral causa que la neurona a su vez
envie una señal eléctrica a través de su axon
a otras sucesivas neuronas
• Basado en la fuerza de interconexión entre
las neuronas la red puede ser capaz de
cómputos y detección de patrones complejos
 Neuronas Reales

Árbol dendrítico Soma Axon

vaina de mielina
terminal axonico
Membrana

Mitocondria
sinapses
Nucleo
Ribosoma
 Sinapsis
• Cuando el árbol dendrítico recibe impulsos eléctricos
sobre un umbral voltaje especifico la neurona manda una
señal eléctrica a través del axon a los terminales
axonicos
• En esos terminales se conectan los terminales axonicos
(a través de sinapsis) a otras neuronas
• Los terminales axonicos se pueden conectar a través de
sinapsis a diferentes partes de la neurona pero
típicamente se considera solo la conexión a otras
dendritas
Sinapse • Dependiendo del neurotransmisor
Axon Dendrita (ion) el potencial inducido en
terminal postsinaptico (dendrita)
puede ser positivo (excitado) o
negativo (inhibidor)
30 nm

vesículas con neurotransmisores

 Neuronas Temporales

• Las neuronas tienen un tiempo de activación del orden

de milisegundos comparado con nanosegundos para
hardware computacional
• El cerebro humano tiene alrededor de 1011 neuronas
con un promedio de 104 conexiones cada una
• Todas las señales de input de otras neuronas se suman
de manera espaciotemporal por la neurona

s1

mV s2

s1 + s2
tiempo
 Polarización de las Neuronas
• Cuando la neurona es estimulada pasado un voltaje umbral
(VT) se despolariza (TDP) la membrana y las bombas de
sodio-potasio paran de actuar, la membrana cambia de
estado y se convierte mas permeable al ion positivo de
NA+ que al entrar a la neurona cambia el potencial a través
de la membrana neuronal a positivo (+ 40mV)
• Después hay un periodo refractario (TR) de ~ 1ms en el
cual se cierran los canales de NA+, la membrana vuelve a
ser permeable a K+, las bombas se activan y la neurona
logra su voltaje inicial a través del escape de K+ en este
periodo la neurona no es susceptible a estímulos sinápticos
 Modelo de una Neurona
• McCulloch and Pitts (1943) desarrollaron el modelo
original de una neurona esta incluyo diferentes inputs
(x), pesos para esos inputs (w), una función nolinear
(f) de transferencia y el Output (O)
• En el modelo original no se incluyo un profesor
(Teacher) para entrenar a la red
• La función no lineal de transferencia usada era el
escalón (hard limit o step function)
• Se incluyo un input de bias para evitar outputs no
deseados cuando los inputs son zero
 Modelo MP de una Neurona

• Se modela la neurona como x1

una red con pesos wi1
wi2 Si Oi
(conexiones sinápticas) desde x2
f
los nodos j al nodo i, wij
wij
xj
• Input neto a la neurona es:
Si =  wij x j Oi
j
1
• Función de output f es sgn():
−1if Si  i Si
Oi = -1
i
1if Si   i (Θi es umbral para neurona i)
 Computación Neuronal
• McCullough y Pitts (1943) mostraron que este modelo
podría calcular funciones lógicas para poder construir
maquinas de estados finitos
• Pueden construir compuertas lógicas (AND, OR, NOT)
• Con estas compuertas pueden calcular cualquier
función lógica usando una red de dos niveles AND-OR
• También se denomina perceptron de una capa
Computación Neuronal
 Introducción a las Redes Neuronales

Contenidos
• Introducción a las neuronas
• Introducción a las redes neuronales artificiales (ANN)
• Introducción a algunos algoritmos de aprendizaje de
las ANNs
 Redes Neuronales Artificiales (ANNs)
• Las ANNs son un paradigma para hacer
computo y para la detección de patrones
basado en la interconexión paralela de
neuronas artificiales
• Las ANNs son un modelo basado en los
complejos sistemas nerviosos de los
animales y seres humanos con su gran
cantidad de interconexiones y paralelismo
• Los comportamientos inteligentes de estos
son una propiedad emergente del gran
numero de unidades no un resultado de
reglas simbólicas o algoritmos
 Redes Neuronales Artificiales (ANNs)
• Las características previamente expuestas de las
neuronas se duplican para crear redes de neuronas
artificiales que tienen capacidades similares de
procesar información en forma paralela.
• Algunas capacidades de las redes neuronales son:
1. Aprendizaje
2. Clasificación
3. Almacenaje de información
4. Interpolarización
5. Adaptación
 Redes Neuronales Artificiales (ANNs)
• Las redes neuronales artificiales recrean o modelan
las características de las neuronas ya mencionadas
en sistemas computacionales de software y
hardware
• Usan grupos de muchas neuronas artificiales (como
la neurona McCulloch-Pitts o MP)
• Usan principios de computación colectiva y
descentralizada (paralela)
• Son capaces de aprender
 Redes Neuronales Artificiales (ANNs)
• Operaciones robustas y resistentes a fallas de
neuronas individuales
• La red hace asociaciones automáticamente
• La red crea el “programa” al ajustar los pesos
durante su aprendizaje
• Al operar requieren de sincronizidad o que las
señales entren al mismo tiempo a todas las neuronas
en el mismo nivel (no así las biológicas que usan la
suma espacio-temporal)
 Redes Neuronales Multicapa
• El modelo de una red neuronal con múltiples capas
difiere de las que hemos visto hasta ahora en que
incluye neuronas en capas escondidas
• Una capa escondida significa que no es visible ni al
input ni al output
• Un perceptron de dos capas puede discernir
regiones poligonales, uno de tres o mas capas puede
discernir regiones arbitrarias (Multi Layer Perceptron
o MLP)
 Redes Neuronales Multicapa

• Estos ANN tienen la capacidad de separar inputs en

múltiples funciones lineales y de esta manera
pueden detectar patrones mas complejos que redes
de una función lineal como las vistas anteriormente
 Redes Neuronales Multicapa
• Este ejemplo de un multilayer neural network es capaz de
resolver el problema del XOR
• Los valores sobre las líneas indican pesos y los en los
círculos indican umbrales (thresholds)
• La función no lineal es un step function con valores de 1 si
el umbral el excedido y de 0 si el umbral no es excedido
• Ejemplo XOR (hay otras soluciones posibles):
 Funciones No Lineales
• Las típicas funciones no lineales (f) usadas en redes neuronales
incluyen: sigmoides, limitante duro (step function), y rampa
• Los sigmoides f(s) son:
– monotonicos (sin discontinuidades)
– bounded (limitados)
– Tiene derivados simples f’(s)=kf(s)[1-f(s)]
– no linear
• Los limitantes duros y rampas son:
– no monotonicos (tiene discontinuidades)
– no tienen derivados simples
– linear (dentro de las áreas con limites)
 Consideraciones Parametricas
• Tamaño: cantidad de neuronas para resolver un problema
• Tipo o paradigma: numero de capas escondidas, numero de neuronas
en cada capa
• Algoritmo de aprendizaje
• Numero de iteraciones durante el aprendizaje
• Numero de cálculos por cada iteración
• Velocidad para reconocer un patrón
• Capacidad de reconocimiento de patrones diferentes
• Grado de adaptabilidad (después de entrenamiento)
• Si requiere de Bias
• Valores de umbral
• Limites (boundaries) de pesos sinápticos
• Selección de función no linear ( f )
• Inmunidad necesaria de la red al ruido
• Valores finales de los pesos (programa final) de la red
 Paradigmas Multicapa
• Multilayer feedforward con una capa escondida

• Multilayer feedforward con capas escondidas y competitiva/cooperativa

 Paradigmas Multicapa
• Bilayer feedforward/backward sin capas escondidas

• Multilayer feedforward/backward
• Monolayer with feedback
• Otras… (aquí entra la imaginacion)
 Introducción a las Redes Neuronales

Contenidos
• Introducción a las neuronas
• Introducción a las redes neuronales artificiales (ANN)
• Introducción a algunos algoritmos de aprendizaje de
las ANNs
 Algoritmos de Aprendizaje
• El proceso de aprendizaje es el proceso por el cual la red
neuronal se adapta al estimulo modificando sus pesos y
eventualmente produce un resultado esperado
• Hay dos tipos de aprendizaje: supervisado y sin
supervisión
• Aprendizaje supervisado incluye un supervisor (o teacher)
que le indica a la red cuan cerca esta de aprender y va
modificando los pesos neuronales
• Sin supervisión solamente se forman grupos de
clasificación de acuerdo a indicaciones o propiedades, no
se calcula un error (E)
• Se puede usar el error o el gradiente de error para que la
red aprenda
• La dirección del gradiente es hacia incrementar el Error
por ende se cambian los pesos hacia la dirección inversa
 Aprendizaje Supervisado
• El modelo de aprendizaje con profesor (teacher) significa
que durante el aprendizaje hay circuitos (o programas)
externos a la neurona que comparan el output deseado (Ti)
con el actual (Oi) y producen el error entre ellas (Ei= Ti - Oi)
• Usando el error (Ei) un algoritmo de aprendizaje modifica
los valores de los pesos uno por uno tratando de minimizar
el error, este proceso requiere de muchas iteraciones
 Aprendizaje usando Perceptron Training

• Se asumen ejemplos de aprendizaje que dan el output

deseado para una neurona dada un conjunto de inputs
conocidos
• Se aprenden pesos para que cada neurona produzca el
output correcto
• Algoritmo es iterativo
• Se usa en perceptrones de una capa
• Red aprende basado en el Error: E = T – O
• Dado que la red aprende usando E se puede usar una
función de transferencia no diferenciable
• El parámetro η es una constante pequeña positiva
conocida como taza de aprendizaje
 Perceptron Learning Procedure
• Actualizar los pesos de la neurona i de acuerdo a:
wij (k +1) = wij (k ) +(Ti − Oi )x j x1
w11
– η es la taza de aprendizaje S1 O1
x2 w12
– Ti es el valor del profesor de neuronai f

w1j
xj
• Equivalente a las reglas:
– Si Ti > Oi se quiere incrementar Oi entonces si xj > 0
se incrementa wi pero si xj < 0 se reduce wi
– Si Ti < Oi se quiere reducir Oi entonces si xj > 0 se
reduce wi pero si xj < 0 se incrementa wi
 Perceptron Learning
Algoritmo:
1- Asignar umbrales y pesos a valores iniciales aleatorios
2- wij(k+1) = wij(k) + η(E(k))xj
3 Se puede usar cualquier función no lineal (f) ya que el
aprendizaje no depende del calculo de un derivado
4 Se continua iterando hasta que se llega a un output
deseado, que se llego a un numero de iteraciones o
que los pesos no están cambiado
 Perceptron como un Separador Lineal
• El perceptron implementa una función lineal del umbral,
de esta forma busca un separador lineal que discrimina
entre las clases
w11x1 + w12 x2  1
x2
w11 1
x2  − x1 +
?? w12 w12
−1if S1  1
O1 =
1if S1  1

x1 Un hyperplano en espacio
de n dimensiones
 Perceptron como un Separador Lineal II

• Un problema es que para aprender patrones diferentes hay

que entrenar la red completamente de nuevo
• Otro problema de esta red es la incapacidad de aprender
funciones no linealmente separables (Ej. XOR) (Minsky 1969)
• Esta incapacidad bajo el interés por el perceptron hasta que
se utilizo en múltiples capas
x2 (+1,+1)
(-1,+1)
XOR
X1 X2 Y Donde poner la línea ??
0 0 0 x1
0 1 1
1 0 1
1 1 0 (-1,-1) (+1,-1)
 Perceptron: Convergencia y Ciclos
• Perceptron convergence theorem: Si los datos son
linealmente separables y un set de pesos existen
que sean consistentes con los datos, entonces el
perceptron eventualmente va a converger en un
conjunto de pesos consistentes con los datos.
• Perceptron cycling theorem: Si los datos no son
linealmente separables el algoritmo eventualmente
va a repetir un conjunto de pesos y umbral
 Espacio de Búsqueda de Pesos como
Minimización

• El espacio de búsqueda es el set de pesos w y un umbral

• Objetivo es minimizar el error de clasificación del conjunto
de entrenamiento
• Esta basado en la idea de que el gradiente de una función
escalar F(w) es un vector que apunta en la dirección del
mayor incremento de F con magnitud dada por la mayor
tasa de cambio de F
 Espacio de Búsqueda de Pesos como
Minimización
• Al ir en la dirección contraria al gradiente:
• Dependiendo de la superficie de búsqueda y de usar
una tasa de aprendizaje pequeña
• Se llega de a un punto b para el cual F(a) ≥ F(b):

b = a −  F (a)
F(w)
F(a) F(w)

isolines
a b
 Aprendizaje usando Gradiente

• Pero para hacer esto se necesita una función de output

que sea diferenciable con respecto a sus inputs y pesos
• La función step (o sign) no es diferenciable en el umbral

oj

0
Θj Sj
 Función de Output Diferenciable

• Sigmoide es una función de activación no lineal

diferenciable

1
oj = 1
1+ e−( S j − j )
0
Θj Sj

También se puede usar función de output tanh o Gausiana

 x1 w11
x2 w12 S1 O1
ADALINE f

w1j
xj
• ADALINE (Widrow) es un modelo de una neurona:
n
S =  wi xi + w0
i=1
• Es entrenado usando el Delta Rule o Least Mean Squared
Error [Mitchell]: r 1

2
E(w ) = (T d − Sd )
2dD
• Se calcula el gradiente del error E(w) y se modifican los
pesos en la dirección contraria (D es el set de ejemplos):
E 1
=  2(Td − S d )(−xid ) = −  (Td − Sd )(xid )
wi 2 dD dD

• Finalmente:
E
wi (k +1) = wi (k ) +  wi (k ) = wi (k ) −  = wi (k ) +   (Td − Sd )( xid )
wi dD
 Delta Learning con función no lineal
sigmoide
• Ha sido usado con redes de 1 o mas capas [Kartalopoulos]
• Basado en minimización del Least Squared Error (LSE)
• Objetivo es expresar la diferencia entre el output deseado (T) y el actual (O
o f(S)) en termino de los inputs y los pesos
−x
• Utiliza la función no lineal sigmoide : f s ( x ) = 1/(1 + e )
• Su derivado : f '(x) = [1− f (x)] f (x)

E(wr ) =  (Td − f (S d ))2

1
• Y el LMS error:
2 dD
• Se calcula el gradiente del error en termino de los pesos :

E 1
=  2(Td − f (S d )) f '(S d )(S') =  (Td − f (S d )) f '(S d )(−xid )
wi 2 dD dD

• Finalmente:
E
wi (k +1) = wi (k ) −  = wi (k ) +  (Td − f (S d )) f '(S d )(xid )
wi dD
 Ejemplo: delta learning algorithm

• 1 neurona (i = 1), iteración inicial = 1:

x(1)1 = (+1, -1, +1, -1), w(1)1 = (+1, -1, 0, -1), T1 =0.55,
µ=0.1, g=1, f(S) = (1 + e-gS)-1 , f '(S) = [1 - f (S)]f(S)
• Lo que se modifican son los pesos w1 basados en los
valores de x1, T1 , f(S) y µ.
x -1
x -1
S O
x 20 f

x +1
 Ejemplo: delta learning algorithm

• Calculando S, f(S) y modificando los pesos

S(1)1= x(1)1•w(1)1 =(+1, -1, +1, -1) (+1, -1, 0, -1)T = 3
O(1)1= f(S(1)1) = f(3) = 0.952574
w(2)1 = w(1)1 + µ[T - O(1)1]f '(S(1)1) x(1)1
= (0.998181, -0.998181, -0.001819, -0.998181)
• Iteración = Iteración + 1
basado en w(2)1 recalcular O(2)1, f '(x1w(2)1), w(3),...etc
• Parar cuando el error es menor o igual al valor deseado
 MADALINE
• El modelo MADALINE usa muchos ADALINEs
en parallelo y una neurona de salida
• Usa un método de selección del output basado
en los inputs (Ej. mayoría o AND)
x x
1 n

f
AND

f
 Otros Algoritmos

• Reforzado:
– Se le indica a la red que ha pasado o fallado o sea el
valor de E es P/F o 1/0
• Competitivo:
– Hay múltiples neuronas en la capa del output y se
entrena la red para que una neurona en el output este
correcta y las otras no producen outputs dependiendo
del estimulo
 Redes Multi Capa

• Redes con múltiples capas pueden representar

funciones arbitrarias
• Cualquier función Booleana puede ser representada con
una capa escondida (incluyendo XOR)

Input Hidden Output

 Backpropagation
• Método usado para el aprendizaje de redes de múltiples capas
• Este es un algoritmo muy usado en redes neuronales de
aprendizaje supervisado, la idea es modificar los pesos basado en
el derivado del Error:

• La función total de Error se define como la suma de las diferencias

al cuadrado medio para todos los patrones presentados k:

• Una función no lineal de transferencia típicamente usada es el

sigmoide f(x):
 Backpropagation (cont)
• Este algoritmo (Werbos 1974) usa “gradient descent
learning” que usa el gradiente del error con respecto
al peso actual (wij) para la modificación del peso (∆wij)
en cada nodo i en el aprendizaje del algoritmo
• En este algoritmo se empieza haciendo cómputos en
la capa de output (L)
• Se procede capa a capa hacia la capa de input (1)
cambiando los pesos en cada capa uno por uno
E
E(k) wk
E(k+1) 
wnm
l
 − Elk
wnm
w(k+1) w(k)
 Backpropagation: modelo de la red
• a la red se le presentan K patrones de aprendizaje xk en el cual 1 < k < K
• el nodo i en la capa l tiene como resultado del input xk el valor Si l(xk)
• el output del nodo i en la capa l es O l = f(S l(x ))
i i k
• el nodo j en la capa previa (l -1) tienen un output de O l-1
j
• el peso entre el nodo j en la capa (l -1) y el nodo i en la capa l es wij l
• la capa de output es la capa L, la capa del input es la capa 1

capa ( l -1) capa ( l ) capa ( l +1)

nodo (1) O1l-1(k)
nodo (1)
Oil(k)
w1il
nodo (i)
Ojl -1 (k) wjil Oil(k)
nodo (j) nodo (j)
l-1
wNil
O N (k)

nodo (Nl-1) nodo (Nl +1 )

 Algoritmo Backpropagation

1. Inicializar los pesos y los valores de bias a valores aleatorios pequeños

2. Presentar input de entrenamiento a la red (x(k), T(k)) en la generación k
3.Calcular outputs de cada neurona i (1< i < Nl) en cada capa l (1 < l <L)
desde el input layer y procediendo hacia el output layer (L)
Nl−1
O (k ) = f (  wim
i
l l
Oml −1 (k))
m=1
4. Calcular el gradiente  i l y la diferencia ∆w ij por cada input de las
neuronas en cada capa desde la capa de output hasta la de input

l=L  iL = (Ti − OiL )OiL (1 − OiL ), wijL =  iLO L−1

j
Nl
l≠L  il = (   rl +1 w ril +1 )O il (1 − O il ),  w ijl =  il O lj −1
r= 1
 Algoritmo Backpropagation (cont)
5. Actualizar los pesos de acuerdo al método de descenso de gradiente

6. Repetir pasos calculando los outputs de la red (próxima iteración)

parar cuando el error es suficientemente pequeño
 Ejemplo1: Backpropagation
• El siguiente ejemplo usa el algoritmo recientemente descrito en
conjunto con la siguiente red neural usando back propagation en un
feedforward NN con una capa escondida (l = 2) y un output (y = O13)
 Ejemplo1: Backpropagation (cont)
• Inicializar los valores de los pesos en cada capa a un valor
aleatorio pequeño (ej. alrededor de 1)
• Presentar inputs (ej. k=1, x(k)=x(1)={1, 1, 0}, T=1, µ=.1)
• Calcular outputs de cada neurona en cada capa de 1 a 3:
– O11 =1, O21 =1, O31 =0
– O12 = f(w111 O11 + w1212 O21), O22 = f(w221 O21 + w232 O31)
– O13 = f(w113 O12 + w123 O22)
• Calcular el gradiente jl y la diferencia wijl para cada input
de las neuronas empezando por la ultima capa (l=3) hacia
la primera (l=1)
 13 = (T - O 13 )O 13(1 - O 13 ), w113 = µ 1 3 O12, w123 = µ 13 O 22
 12 = (Σ  r3 wr13)O12(1 - O 12) = ( 13 w 113 ) O1 2(1 - O12)
 22 = (Σ  r3 wr23)O22(1 - O 22) = ( 13 w123 ) O2 2(1 - O22)
 wij2 = µ  i2 Oj1 → w112 = µ 12 O 11, w 122 = µ 12 O 21,
w222 = µ 22 O21, w232 = µ 22 O31
 Ejemplo1: Backpropagation (cont)
• Actualizar los pesos usando: w l (k +1) = w l (k ) + w l (k )
ij ij ij

• Entonces por ejemplo : w ( 2 ) = w (1) +  w (1)

2
11
2
11
2
11

• Calcular todos los pesos desde w112(2) hasta

w123(2)
• Ahora calcular Y y determinar el error E(2). Si el E(2) es
menor que lo deseado terminar el proceso de otra
manera volver al paso 2 para repetir el proceso y
generar E(3) etc...
 Ejemplo2: Backpropagation
• Ej: Para que la red aprenda un set de ocho patrones xi y Ti :
• x1(k)={0, 0, 0}, T1=1, x2(k)={0, 0, 1}, T2=0,
• x3(k)={0, 1, 0}, T3=0, x4(k)={0, 1, 1}, T4=1,
• x5(k)={1, 0, 0}, T5=1, x6(k)={1, 0, 1}, T6=0,
• x7(k)={1, 1, 0}, T7=1, x8(k)={1, 1, 1}, T8=1

• Son ocho miembros de este set: xi, Ti, 0  i  8

A- Se calculan (ver el Ej. anterior) ocho outputs: O 13[i] y ocho errores

(Ei = | O 13 [i] – T |i ) : E ,1E ,...,
2 E 8
C- Si el max(E1,..., E8) es bajo un valor entonces la red aprendió (Ej.
0.05%)
D- Si la red no aprendió se calculan los gradientes y modifican los
pesos (ocho veces) basado en los Ti y O13
E- Se repiten los pasos de A a D hasta que las generaciones (k) se
exhausten o hasta que la red aprenda
 Ejemplo3: Backpropagation
• Primero calcular el error de neuronas de output y usar
esto para cambiar pesos de entrada a estas neuronas

Output actual: oi=0.2

Output correcto: ti=1.0
Error δiL = o i(1–o i)(t i–o i) output
0.2(1–0.2)(1–0.2)=0.128
Actualizar pesos entre nodos j e i
wij =  i o j hidden
L L-1

input
 Ejemplo3: Backpropagation

• Después se calcula el error para capas escondidas

basado en los errores de unidades de output

output

 i l = oi l (1− oi l )  k l+1wkil+1
k hidden

input
 Ejemplo3: Backpropagation

• Finalmente se actualiza la capa de input de pesos

basados en los errores calculados para capa escondida

output

 i l = oi l (1− oi l )  k l+1wkil+1
k
hidden
l l -1
wij =  i o j

input
 Algoritmo Backpropagation
• No es garantizado que converja a zero en error de
entrenamiento, puede converger a mínima local o
oscilar
• En la practica converge a un bajo error para muchas
redes
• Muchas épocas (miles de iteraciones) pueden ser
requeridas
• Para evitar mínima local usar varias corridas (runs)
con pesos inicializados aleatoriamente (random
restarts).
– Tomar resultados de red que da menor error
 Poder de Representación

• Funciones Booleanas: Cualquier función booleana se

puede representar con una red de dos capas con
suficientes neuronas en la capa escondida
• Funciones Continuas: Cualquier función continua
limitada (bounded) puede ser aproximada con un error
arbitrariamente pequeño con una red de dos capas
– Funciones sigmoidales puede actuar como set de funciones
bases para componer funciones mas complejas (como análisis
Fourier)
• Funciones Arbitrarias: Cualquier función puede ser
aproximada con una red de tres capas
 Sobre Aprendizaje (Over-Training)
• Correr muchas iteraciones puede causar sobre
aprendizaje (over-fitting o over-training).
error

test data

training data
0 # training epochs
• Hay que mantener un set de validación para probar
la precisión después de cada iteración.
• Se detiene el entrenamiento cuando iteraciones
adicionales incrementan el error de validación.
 Determinando el Numero de Neuronas
Escondidas
• Muy pocas neuronas escondidas causan que la red no
pueda aprender la función deseada correctamente.
• Muchos nodos escondidos causan sobre aprendizaje.
error

test data

training data
0 # hidden units
• Se debe obtener empíricamente con diferentes
configuraciones de la red.
 Aprendizaje no supervisado

• Hebbian learning
wi = xi y
– los pesos en una neurona es incrementada
de acuerdo a la actividad correlacionada
entre su input y actividad post sinaptica
(dado su output)
– Neuronas que disparan juntas se conectan
mas fuertemente
– En este algoritmo el valor Ti no existe
y=wx
j j
– Los pesos tienen valores iniciales pequeños j
– Se comienza con una tasa de aprendizaje
pequeña
x1 wi11
wi21 Si1 Oi1 xj wji2 Sj3 Oj3
x2
f f

wiN1
xN
 Aprendizaje no supervisado

• Self Organizing Map (SOM)

– Introducidos por Teuvo Kohonen como Kohonen Maps, Un mapa
SOM es un tipos de red neuronal que se entrena sin supervisión
para producir una salida discretizada de baja dimensión de las
entradas (i.e. un mapa)
– Usan una función de vecindad para preservar propiedades del
espacio de entrada
– Las redes SOM operan en dos modos, entrenamiento y mapeo,
en entrenamiento se elije la neurona que mas aproxima al vector
de entrada como la solución para esa entrada y se repite
iterativamente hasta tener neuronas asociadas a cada entrada
– En la etapa de mapeo se entrega una entrada y la red la clasifica
 Aprendizaje no supervisado

• Self Organizing Map (SOM)

– El procedimiento para poner un vector desde el espacio de datos
al mapa es encontrar el nodo con el vector de pesos más similar
al vector de entrada y asignarle los valores del vector de entrada.

– En el ejemplo, se ve como el nodo mas cercano (en amarillo) al

vector objetivo (en rojo) es asignado ese valor, se puede
ponderar el grado de acercamiento de los nodos dada su
distancia (e.g. Euclideana) al vector (i.e. punto) objetivo.
– Eventualmente la red SOM tiende a tomar los valores de los
datos de entrada.
 Aprendizaje no supervisado

• Self Organizing Map (SOM)

– Usando aprendizaje competitivo, cuando un ejemplo se muestra
a la red, su distancia Euclidiana a todos los vectores de pesos de
los nodos se calcula.
– El nodo (i.e. neurona) mas similar se denomina la Best Matching
Unit (BMU), los pesos de la BMU y las neuronas cercanas se
ajustan en dirección del vector de entrada del ejemplo.
– La magnitud del cambio es decreciente con tiempo y distancia a
la BMU. La formula de actualización para una neurona con vector
de pesos Wv(t) es:

Wv(t + 1) = Wv(t) + Θ (v, t) α(t)(D(t) - Wv(t)),

– donde α(t) es un coeficiente de aprendizaje decreciente
monotonicamente y D(t) es el vector de entrada.
– La función de cercanía Θ (v, t) depende de la distancia entre el
BMU y la neurona v. En los casos mas simples es 1 para todas la
neuronas cerca de la BMU y 0 para las otras pero una función
Gaussiana es otra posible elección.
 Redes Neuronales

Referencias:
[1] Jang, J-S.R. Et al, “Neuro-Fuzzy and Soft Computing”,
Prentice Hall, 1997
[2] Neelakanta, P., DeGroff, D., Neuronal Network Modeling,
CRC, Boca Raton, 1994
3 Mitchel , T., “Machine Learning”, McGraw-Hill, 1997
4 Mooney, R., Apuntes Curso University of Texas, 2006
5 Simulador NN: www-ra.informatik.uni-tuebingen.de/SNNS/
6 Kartalopoulos, S., Understanding Neuronal Networks and
Fuzzy Logic, IEEE Press, 1994
7 Dowla, F., Rogers, L., Solving Problems in Environmental
Engineering and Geosciences with Artificial Neuronal
Networks, MIT Press, 1995
8 http://en.wikipedia.org/wiki/Hebbian_theory
9 http://en.wikipedia.org/wiki/Self-organizing_map
 Keras en la
creación de
RNA
Uso de Keras en la creación de
Redes Neuronales Atificiales
con Python

Ph.D. Darwin Patiño Pérez

 Un tipo de modelo de Machine Aprenden apartir de datos.
Learning.

Redes Neuronales
Artificiales

Que Son ?
Generalmente se usan en un Regresión(cuando son
tipo de aprendizaje numeros) o
supervisado. A partir de datos Clasificación(cuando se trata
de entrada y salidas. de etiquetas).
 Aprendizaje
Supervisado
Aquí lo que se busca, es la función que relaciona los
datos de entrada, con los datos de salida; Si por
ejemplo los datos de entrada son caballos entonces
buscamos las etiquetas de salida llamada “caballo”.

La idea es que esa función

hallada a futuro sea capaz de
reconocer cualquier entrada
nueva que llegue.
 DataSet
Característica Etiqueta
Área(m^2) Precio
234 600
C 125 500
a 421 200
s 250 500
a 320 600
s 431 700
520 800

Como lo hace ?

modelo paramétrico
NEURONA: En su forma mas básica
El cuerpo central, llamado soma, contiene el núcleo celular.
Una prolongación del soma, es el axón.
Un conjunto de ramificaciones terminales, las dendritas.
Las zonas de conexión entre una neurona y otra, son conocidas como sinapsis.

La Neurona
Biológica

La función principal de las neuronas es la transmisión de impulsos nerviosos. Estos viajan por toda la neurona
comenzando por las dendritas hasta llegar a las terminaciones del axón, donde pasan a otra neurona por medio de la
conexión sináptica.
Modelo neuronal de McCulloch-Pitts.
El primer modelo matemático de una neurona artificial, fue creado con el fin de llevar a cabo tareas simples, fue presentado
en el año 1943 en un trabajo conjunto entre el psiquiatra y neuroanatomista Warren McCulloch y el matemático Walter Pitts.

La Neurona
Artificial

-Un conjunto de entradas x1,…xn

-Los pesos sinápticos w1,…wn, correspondientes a cada entrada.
-Una función de agregación, Σ
-Una función de activación, f
-Una salida, Y
 La Neurona
Artificial

cada entrada x tiene asociado un peso p, por lo que p4= σ(𝑋𝑛 ∗ 𝑃𝑛)
Red Neuronal
 Características de KERAS

Biblioteca para armar y entrenar redes neuronales en Python.

Bandas de cosas ya resueltas.
Corre todo sobre TensorFlow(default) o Theano.
Soporte para correr sobre GPU.

STACK
Keras
keras

TensorFlow

cuda

CPU GPU
 # Importar librerías

# Cargar la información
Secciones para la
# Declaración de variables importantes
creación de un
# Crear el modelo
modelo de red
neuronal artificial # Agregar capas

usando # Compilar

# Entrenar

Keras
Secciones para la
creación de un
modelo

Keras
Secciones para la
creación de un
modelo

Keras
 Librerías y
paquetes de
Python
 # Importar librerías
Se importan las Librerías(Keras y Pandas) así como los paquetes(Sequential y
Dense)

import keras
from keras.models import Sequential
from keras.layers import Dense

import pandas as pd

# Cargar la información
Secciones para Usando Pandas se carga el dataset

crear un modelo en data = pd.read_csv('concrete_data.csv’)

Keras # Declaración de variables importantes

1)se asigna a data_columnas las columnas del dataset
2)se asigna a labels las propiedades del concreto que están en las columnas de las
propiedades diferentes a la fuerza.
3)se asigna a target la columna que contiene la etiqueta fuerza que es la que
queremos predecir.
4)ncols que lo obtengo con shape[1] la segunda posición es columna la primera
es el numero de filas.

data_columnas = data.columns
labels = data[data_columnas[data_columnas != 'Strength']]
target = data['Strength']
n_cols = labels.shape[1]
 #CREANDO LA RED NEURONAL CON KERAS
# Importar librerías
Se importan las Librerías(Keras y Pandas) así como los paquetes(Sequential
y Dense)
# Cargar la información
Usando Pandas se carga el dataset
# Declaración de variables importantes
1)se asigna a data_columnas las columnas del dataset
2)traigo los labels que son las propiedades del concreto diferentes y que
son diferentes a la fuerza o target que queremos predecir.
La Neurona 3)traigo la columna target que es la fuerza
4)ncols que lo obtengo con shape[1] la segunda posición es columna la
primera es el numero de filas
Artificial # Crear el modelo
Keras tiene 2 tipos de modelos, el secuencial y el funcional, escogemos el
modelo secuencial.
# Agregar capas
una vez creado el modelo, lo alimentamos con capas, de entrada con dos
capas, la primera que será la de input (a la cual le inyectaremos los datos ) y
a la ultima la output que tendrá la predicción las de en medio son las hidden
layers y cuando hay muchas capas hemos pasado de machine learning a
deeplearning.
cada entrada x tiene asociado un peso p, por lo que p4= σ(𝑋𝑛 ∗ 𝑃𝑛)
# Compilar
Se compila
# Entrenar
Se entrena
 #Use to import pandas

import pandas as pd

#Use to import the file into google Colab drive

from google.colab import files

#Esto abrirá un widget cuando se ejecute que permitirá

#explorar los archivos de la unidad de almacenamiento.

Cargar un .csv uploaded = files.upload()

desde colab de # Now use the below code to read the csv in pandas' dataframe
# df = pd.read_csv(io.StringIO(uploaded[‘f.csv'].decode('utf-8')))
Google df = pd.read_csv('equiposF.csv’,sep=‘,’,header=0)

print(df)

print(df.head())

print(df.ix[0:3])
Usando pandas
print(df[‘Nombre’])
 Cinco pasos básicos para implementar la regresión lineal

1)Importar los paquetes y clases que se necesitan.

Regresión Lineal 2)Proporcionar los datos para trabajar y eventualmente realizar las

Simple transformaciones apropiadas.

3)Crear un modelo de regresión y ajustarlo con los datos existentes.
con 4)Verificar los resultados del ajuste del modelo para saber si el modelo es
satisfactorio.
5)Aplicar el modelo para predicciones.

scikit-learn
 #En colab de Google

import csv
import pandas as pd
from google.colab import files
uploaded = files.upload()
df = pd.read_csv('equiposF.csv',sep=';',header=0)
print(df)

#En spyder: el dataset .csv y el programa.py debe estar en

Cargar .csv desde la misma carpeta.
diferentes import pandas as pd
ambientes df = pd.read_csv('equiposF.csv',sep=';',header=0)
print(df)

#En kaggle: selecciono Home y en Your Datasets hago clip

en ‘+’ y cargo data.csv y en la caja Enter Dataset Title pongo
el nombre de la carpeta dataset quedando todo dentro de
input.

import pandas as pd
df = pd.read_csv('../input/dataset/data.csv', index_col=0)
print(df)
 #En Visual Studio Code: aquí se pone la ruta de la capeta de
donde esta el .csv a leerse.

import pandas as pd
df = pd.read_csv('E:/CICLO-2/IA/pandas/data.csv', index_col=0)
print(df)

#En Jupyter: aquí se pone la ruta de la capeta de donde esta el

.csv a leerse.
Cargar .csv desde import pandas as pd
diferentes df = pd.read_csv('E:/CICLO-2/IA/pandas/data.csv', index_col=0)
print(df)
ambientes
En el Aprendizaje Supervisado los datos para el entrenamiento incluyen la solución deseada, llamada «etiquetas» (labels).

Los algoritmos más utilizados en Aprendizaje Supervisado son:

• k-Nearest Neighbors – Ejercicio en Python
• Linear Regression – Nuevo! Ejercicio Python paso a paso
• Logistic Regression – Ejemplo en Python
Aprendizaje • Support Vector Machines
Supervisado • Bayesian Classifiers – Teoría y Ejemplo en Python
• Decision Tress and Random Forest – Ejemplo árbol en español
• Neural Networks – Nuevo! Sencillo ejemplo Python Keras en 15 líneas
• Deep Learning

Un claro ejemplo es al clasificar correos entrante entre Spam o no. Entre las diversas características que queremos entrenar
deberemos incluir si es correo basura o no con un 1 o un 0. Otro ejemplo son al predecir valores numéricos por ejemplo
precio de vivienda a partir de sus características (metros cuadrados, nº de habitaciones, incluye calefacción, distancia del
centro, etc.) y deberemos incluir el precio que averiguamos en nuestro set de datos.
En el aprendizaje No Supervisado los datos de entrenamiento no incluyen Etiquetas y el algoritmo intentará clasificar o
descifrar la información por sí solo.

Los algoritmos más importantes de Aprendizaje No supervisado

son:
• Clustering K-Means (ejercicio paso a paso)
• Principal Component Analysis
• Anomaly Detection
Aprendizaje No
Supervisado

Un ejemplo en el que se usa es para agrupar la información recolectada sobre usuarios en una Web o en una app y que nuestra
Inteligencia detecte diversas características que tienen en común.
En el Aprendizaje por Refuerzo, Nuestro sistema será un «agente autónomo» que deberá explorar «un espacio» desconocido y
determinar las acciones a llevar a cabo mediante prueba y error. Creará la mejor estrategia posible (políticas) para obtener la
mayor recompensa posible en tiempo y forma. Las políticas definirán qué acciones tomar ante cada situación a la que se
enfrente.

• Procesos de Decisión de Markov (MDP: Markov Decision Process)

Aprendizaje por
Refuerzo

Aprenderá por sí mismo obteniendo premios -recompensas- y penalidades la forma óptima para recorrer un camino, resolver
un puzzle o comportarse por ejemplo en el Pac Man o en el Flappy Bird.
MACHINE LEARNING

Avances en la
Inteligencia Artificial

Ph.D. Darwin Patiño Pérez

MACHINE LEARNING

AGENDA

1 EL ORIGEN

2 LA DEFINICION

3 TIPOS DE APRENDIZAJE

4 PAQUETERIA EN PYTHON

5 DESARROLLOS

6 CONCLUSION
 El origen del
Machine Learning
• Se originó en la década de los 60.

• En los 90 se separara de la IA para

convertirse en una disciplina por sí sola.

• El principal interés era que las

computadoras pudieran aprender
únicamente basándose en datos.

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 3
O R G Á N I C O S
Actualmente • El principal objetivo es abordar y resolver
problemas prácticos aplicando disciplinas
Machine Learning numéricas avanzadas.

- El razonamiento probabilístico

- La investigación basada en la estadística

- De la rápida recuperación de información

- Profundizando cada vez más en el

reconocimiento de patrones.

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 4
O R G Á N I C O S
 Definiendo
Machine Learning “Machine Learning es la ciencia que
permite que las computadoras aprendan
y actúen como lo hacen los humanos,
mejorando su aprendizaje a lo largo del
tiempo de una forma autónoma,
alimentándolas con datos e información
en forma de observaciones e
interacciones con el mundo real.” — Dan
Fagella

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 5
O R G Á N I C O S
Tipos de
Machine Learning
y sus aplicaciones.

Deep Laearning

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 6
O R G Á N I C O S
 Aprendizaje
Supervisado
El entrenamiento es con un conjunto de
ejemplos en los que los resultados de salida son
conocidos.

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 7
O R G Á N I C O S
 Aprendizaje no
Supervisado
En el aprendizaje no supervisado, trataremos
con datos sin etiquetar cuya estructura es
desconocida.
Ejemplos: detectar morfología en oraciones, clasificar
El objetivo será la extracción de información información, etc.
significativa, sin la referencia de variables de
salida conocidas, y mediante la exploración de
la estructura de dichos datos sin etiquetar.

Hay dos categorías principales:

agrupamiento y reducción dimensional.

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 8
O R G Á N I C O S
 Deep Learning
El aprendizaje profundo ó Deep Learning, es
un subcampo de Machine Learning, que usa
una estructura jerárquica de redes neuronales
artificiales, que se construyen de una forma
similar a la estructura neuronal del cerebro
humano, con los nodos de neuronas
conectadas como una tela de araña.
.

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 9
O R G Á N I C O S
Arquitectura de Red Neuronal

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 10
O R G Á N I C O S
Arquitectura de Red Neuronal

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 11
O R G Á N I C O S
Arquitectura de Red Neuronal

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 12
O R G Á N I C O S
Arquitectura de Red Neuronal

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 13
O R G Á N I C O S
 Características:

Scikit-Learn • Herramientas simples y eficientes para la minería de datos

y el análisis de datos.
• Accesible para todos, robusta, flexible y reutilizable en
diversos contextos.
Es la librería para el lenguaje de • Open Source, comercialmente utilizable – licencia BSD.
programación Python que proporciona • Su robustez la hace perfecta para usar en cualquier
una amplia selección de algoritmos de proyecto de Aprendizaje Automático (Machine Learning)
aprendizaje automático en contextos de inicio a fin, desde la fase de investigación hasta la de
supervisados y no supervisados. implementación y producción.

¿Qué ofrece Scikit Learn?

Scikit Learn está construido sobre varias bibliotecas Python

para el procesamiento de datos y manejo de funciones
matemáticas y algebraicas, facilitando la integración de sus
componentes.

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 15
O R G Á N I C O S
 Incluye un robusto conjunto de algoritmos como:
Scikit-Learn? Regresión: Ajuste de modelos lineales y no lineales.
Agrupación: Clasificación no supervisada.
Utiliza las siguientes bibliotecas: Árboles de decisión: Inducción y poda de árboles para
tareas de clasificación y de regresión.
NumPy: Para trabajar con matrices, Redes neuronales: Entrenamiento de extremo a extremo
especialmente operaciones matemáticas. para clasificación y regresión. Las capas se pueden definir
SciPy: Computación científica y técnica. fácilmente en una tupla.
Matplotlib: Para visualización de datos. Máquinas de soporte vectorial (SVMs): Para aprendizaje
IPython: Consola interactiva ara Python supervisado.
Sympy: Matemáticas simbólica. Naive Bayes o el Ingenuo Bayes: Modelado probabilístico
Pandas: Manejo, manipulación y análisis directo; es uno de los algoritmos más simples y poderosos
de datos para la clasificación basado en el Teorema de Bayes

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 16
O R G Á N I C O S
 Conclusión
El machine Learning evolucionara a un nivel de control de micro
arquitecturas que le permitirán al ser humano dar el siguiente salto
evolutivo.

MUCHAS GRACIAS!!!!

LO MEJOR PARA usted

E M P R E S A D E C O M P U E S T O S 17
O R G Á N I C O S
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos

Python para PNL: tokenización, derivación y

lematización con la biblioteca SpaCy

En el artículo anterior, comenzamos nuestra discusión sobre cómo hacer procesamiento de

lenguaje natural con Python. Vimos cómo leer y escribir archivos de texto y PDF. En este artículo,
comenzaremos a trabajar con espacio biblioteca para realizar algunas tareas más básicas de PNL,
como tokenización, derivación y lematización.

Introducción a SpaCy

Contenido [mostrar]

La biblioteca spaCy es una de las bibliotecas NLP más populares junto con NLTK. La diferencia
básica entre las dos bibliotecas es el hecho de que NLTK contiene una amplia variedad de
algoritmos para resolver un problema, mientras que spaCy contiene solo uno, pero el mejor
algoritmo para resolver un problema.

NLTK se lanzó en 2001, mientras que spaCy es relativamente nuevo y se desarrolló en 2015. En
esta serie de artículos sobre PNL, nos ocuparemos principalmente de spaCy, debido a su
naturaleza de vanguardia. Sin embargo, también tocaremos NLTK cuando sea más fácil realizar
una tarea usando NLTK en lugar de spaCy.

Instalación de spaCy

Si usa el instalador de pip para instalar sus bibliotecas de Python, vaya a la línea de comando y
ejecute la siguiente declaración:

$ pip install -U spacy

De lo contrario, si está utilizando Anaconda, debe ejecutar el siguiente comando en el indicador

de Anaconda:

$ conda install -c conda-forge spacy

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 1/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos

Una vez que descargue e instale spaCy, el siguiente paso es descargar el modelo de idioma.
Usaremos el modelo de idioma inglés. El modelo de lenguaje se utiliza para realizar una variedad
de tareas de PNL, que veremos en una sección posterior.

El siguiente comando descarga el modelo de lenguaje:

$ python -m spacy download en

Funcionalidad básica

Antes de profundizar en las diferentes funciones de SpaCy, veamos brevemente cómo trabajar
con él.

Como primer paso, debe importar el spacy biblioteca de la siguiente manera:

import spacy

A continuación, necesitamos cargar el modelo de lenguaje spaCy.

sp = spacy.load('en_core_web_sm')

En el script de arriba usamos el load función de la spacy biblioteca para cargar el modelo
básico del idioma inglés. El modelo se almacena en el sp variable.

Creemos ahora un pequeño documento usando este modelo. Un documento puede ser una
oración o un grupo de oraciones y puede tener una extensión ilimitada. La siguiente secuencia
de comandos crea un documento spaCy simple.

sentence = sp(u'Manchester United is looking to sign a forward for $90 million')

SpaCy divide automáticamente su documento en tokens cuando se crea un documento

utilizando el modelo.

Una ficha simplemente se refiere a una parte individual de una oración que tiene algún valor
https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 2/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos
Una ficha simplemente se refiere a una parte individual de una oración que tiene algún valor
semántico. Veamos qué tokens tenemos en nuestro documento:

for word in sentence:

print(word.text)

La salida del script anterior se ve así:

Manchester

United

is

looking

to

sign

forward

for

90

million

Puede ver que tenemos los siguientes tokens en nuestro documento. También podemos ver el
partes de la oración de cada uno de estos tokens usando el .pos_ atributo que se muestra a
continuación:

for word in sentence:

print(word.text, word.pos_)

Salida:

Manchester PROPN

United PROPN
is VERB

looking VERB

to PART
https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 3/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos
to PART

sign VERB

a DET

forward NOUN

for ADP

$ SYM

90 NUM

million NUM

Puede ver que a cada palabra o símbolo de nuestra oración se le ha asignado una parte del
discurso. Por ejemplo, «Manchester» ha sido etiquetado como un nombre propio, «Looking» ha
sido etiquetado como un verbo, y así sucesivamente.

Finalmente, además de las partes del discurso, también podemos ver las dependencias.

Creemos otro documento:

sentence2 = sp(u"Manchester United isn't looking to sign any forward.")

Para el análisis de dependencias, el atributo dep_ se utiliza como se muestra a continuación:

for word in sentence2:

print(word.text, word.pos_, word.dep_)

La salida se ve así:

Manchester PROPN compound

United PROPN nsubj

is VERB aux

n't ADV neg

looking VERB ROOT

to PART aux

sign VERB xcomp

any DET advmod

forward ADV advmod

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 4/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos

. PUNCT punct

En la salida, puede ver que spaCy es lo suficientemente inteligente como para encontrar la
dependencia entre los tokens, por ejemplo, en la oración teníamos una palabra is'nt . El
analizador de dependencias lo ha dividido en dos palabras y especifica que el n't es en
realidad la negación de la palabra anterior.

Para obtener una comprensión detallada del análisis de dependencias, consulte Este artículo.

Además de imprimir las palabras, también puede imprimir frases de un documento.

document = sp(u'Hello from Pharos.sh. The site with the best Python Tutorials.

What are you looking for?')

Ahora, podemos iterar a través de cada oración usando el siguiente script:

for sentence in document.sents:

print(sentence)

La salida del script se ve así:

Hello from Pharos.sh.

The site with the best Python Tutorials.

What are you looking for?

También puede verificar si una oración comienza con un token en particular o no. Puede obtener
tokens individuales usando un índice y los corchetes, como una matriz:

document[4]

En la secuencia de comandos anterior, buscamos la quinta palabra en el documento. Tenga en

cuenta que el índice comienza desde cero y el período cuenta como un token. En la salida
debería ver:

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 5/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos

The

Ahora para ver si alguna oración en el documento comienza con The , podemos usar el
is_sent_start atributo como se muestra a continuación:

document[4].is_sent_start

En la salida, verá True desde el token The se utiliza al comienzo de la segunda oración.

En esta sección, vimos algunas operaciones básicas de la biblioteca spaCy. Ahora profundicemos
y veamos la tokenización, la derivación y la lematización en detalle.

Tokenización

Como se explicó anteriormente, la tokenización es el proceso de dividir un documento en

palabras, signos de puntuación, dígitos numéricos, etc.

Veamos la tokenización de spaCy en detalle. Cree un nuevo documento usando el siguiente

script:

sentence3 = sp(u'"They're leaving U.K. for U.S.A."')

print(sentence3)

Puede ver que la oración contiene comillas al principio y al final. También contiene signos de
puntuación en las abreviaturas «Reino Unido» y «EE. UU.»

Veamos cómo spaCy tokeniza esta oración.

for word in sentence3:

print(word.text)

Salida:

"

They

're

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 6/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos

leaving

U.K.

for

U.S.A.

"

En la salida, puede ver que spaCy ha tokenizado las comillas dobles inicial y final. Sin embargo, es
lo suficientemente inteligente como para no simbolizar el punto de puntuación utilizado entre
las abreviaturas como Reino Unido y EE. UU.

Veamos otro ejemplo de tokenización:

sentence4 = sp(u"Hello, I am non-vegetarian, email me the menu at

[email protected]")

print(sentence4)

Aquí, en la oración anterior, tenemos un guión en la palabra «no vegetariano» y en la dirección

de correo electrónico. Veamos cómo spaCy tokenizará esto:

for word in sentence4:

print(word.text)

Salida:

Hello

am

non

vegetarian

email

me

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 7/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos
e

the

menu

at

[email protected]

Es evidente por el resultado que spaCy fue capaz de detectar el correo electrónico y no lo
tokenizó a pesar de tener un «-«. Por otro lado, la palabra «no vegetariano» fue tokenizada.

Veamos ahora cómo podemos contar las palabras en el documento:

len(sentence4)

En la salida, verá 14, que es el número de tokens en el sentence4 .

Detectando Entidades

Además de convertir los documentos en palabras, también puede encontrar si la palabra es una
entidad como una empresa, lugar, edificio, moneda, institución, etc.

Veamos un ejemplo simple de reconocimiento de entidad con nombre:

sentence5 = sp(u'Manchester United is looking to sign Harry Kane for $90

million')

Primero intentemos simplemente tokenizarlo:

for word in sentence5:

print(word.text)

Salida:

Manchester

United

is

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 8/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos

looking

to

sign

Harry

Kane

for

90

million

Sabemos que «Manchester United» es una sola palabra, por lo tanto, no debe dividirse en dos
palabras. De manera similar, «Harry Kane» es el nombre de una persona y «$ 90 millones» es un
valor monetario. Estos tampoco deben ser tokenizados.

Aquí es donde reconocimiento de entidad nombrada viene a jugar. Para obtener las entidades
nombradas de un documento, debe usar el ents atributo. Recuperemos las entidades
nombradas de la oración anterior. Ejecute el siguiente script:

for entity in sentence.ents:

print(entity.text + ' - ' + entity.label_ + ' - ' +

str(spacy.explain(entity.label_)))

En el script anterior, imprimimos el texto de la entidad, la etiqueta de la entidad y el detalle de la

entidad. La salida se ve así:

Salida:

Manchester United - ORG - Companies, agencies, institutions, etc.

Harry Kane - PERSON - People, including fictional

$90 million - MONEY - Monetary values, including unit

Puede ver que el reconocedor de entidades con nombre de spaCy ha reconocido con éxito al
«Manchester United» como organización, a «Harry Kane» como persona y «$ 90 millones» como
valor monetario.

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 9/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos

Detectar sustantivos

Además de detectar entidades con nombre, también se pueden detectar sustantivos. Para
hacerlo, el noun_chunks se utiliza el atributo. Considere la siguiente oración:

sentence5 = sp(u'Latest Rumours: Manchester United is looking to sign Harry Kane

for $90 million')

Intentemos encontrar los sustantivos de esta oración:

for noun in sentence5.noun_chunks:

print(noun.text)

Salida:

Latest Rumours

Manchester United

Harry Kane

En la salida, puede ver que un sustantivo también puede ser una entidad con nombre y viceversa.

Derivado

La raíz se refiere a reducir una palabra a su forma raíz. Mientras realiza tareas de procesamiento
del lenguaje natural, encontrará varios escenarios en los que encontrará diferentes palabras con
la misma raíz. Por ejemplo, computación, computación, computación, computación, etc. Es
posible que desee reducir las palabras a su forma raíz en aras de la uniformidad. Aquí es donde
entra en juego la derivación.

Puede resultarle sorprendente, pero spaCy no contiene ninguna función para derivar, ya que se
basa únicamente en la lematización. Por lo tanto, en esta sección usaremos NLTK para derivar.

Hay dos tipos de lematizadores en NLTK: Porter Stemmer y Levantadores de bolas de nieve.
Ambos se han implementado utilizando diferentes algoritmos.

Porter Stemmer
https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 10/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos

Veamos a Porter Stemmer en acción:

import nltk

from nltk.stem.porter import *

Creemos una clase de PorterStemmer .

stemmer = PorterStemmer()

Supongamos que tenemos la siguiente lista y queremos reducir estas palabras a la raíz:

tokens = ['compute', 'computer', 'computed', 'computing']

La siguiente secuencia de comandos busca la raíz de las palabras de la lista utilizando porter
stemmer:

for token in tokens:

print(token + ' --> ' + stemmer.stem(token))

El resultado es el siguiente:

compute --> comput

computer --> comput

computed --> comput

computing --> comput

Puede ver que las 4 palabras se han reducido a «comput», que en realidad no es una palabra en
absoluto.

Vástago de bola de nieve

La despalilladora de bola de nieve es una versión ligeramente mejorada de la podadora Porter y

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 11/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos
generalmente se prefiere sobre esta última. Veamos el tallador de bolas de nieve en acción:

from nltk.stem.snowball import SnowballStemmer

stemmer = SnowballStemmer(language="english")

tokens = ['compute', 'computer', 'computed', 'computing']

for token in tokens:

print(token + ' --> ' + stemmer.stem(token))

En el guión anterior, usamos Snowball Stemmer para encontrar la raíz de las mismas 4 palabras
que usamos con Porter Stemmer. La salida se ve así:

compute --> comput

computer --> comput

computed --> comput

computing --> comput

Puedes ver que los resultados son los mismos. Todavía tenemos «comput» como raíz.
Nuevamente, esta palabra «comput» en realidad no es una palabra de diccionario.

Aquí es donde la lematización resulta útil. La lematización reduce la palabra a su raíz tal como
aparece en el diccionario. Las raíces devueltas a través de la lematización son palabras reales del
diccionario y están semánticamente completas a diferencia de las palabras devueltas por la raíz.

Lematización

Aunque no pudimos realizar la derivación con spaCy, podemos realizar la lematización usando
spaCy.

Para hacerlo, necesitamos usar el lemma_ atributo en el documento spaCy. Supongamos que
tenemos la siguiente oración:

sentence6 = sp(u'compute computer computed computing')

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 12/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos

Podemos encontrar las raíces de todas las palabras usando la lematización espacial de la
siguiente manera:

for word in sentence6:

print(word.text, word.lemma_)

La salida del script anterior se ve así:

compute compute

computer computer

computed compute

computing computing

Puede ver que, a diferencia de las raíces donde la raíz que obtuvimos fue «comput», las raíces
que obtuvimos aquí son palabras reales en el diccionario.

La lematización convierte las palabras en la segunda o tercera forma a sus primeras variantes de
forma. Mira el siguiente ejemplo:

sentence7 = sp(u'A letter has been written, asking him to be released')

for word in sentence7:

print(word.text + ' ===>', word.lemma_)

Salida:

A ===> a

letter ===> letter

has ===> have

been ===> be

written ===> write

, ===> ,

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 13/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos
asking ===> ask

him ===> -PRON-

to ===> to

be ===> be

released ===> release

Puede ver claramente en el resultado que las palabras en la segunda y tercera forma, como
«escrito», «liberado», etc., se han convertido a la primera forma, es decir, «escribir» y «liberar».

Conclusión

La tokenización, la derivación y la lematización son algunas de las tareas de procesamiento del

lenguaje natural más fundamentales. En este artículo, vimos cómo podemos realizar Tokenización
y Lematización usando la biblioteca spaCy. También vimos cómo se puede usar NLTK para
derivar. En el próximo artículo, comenzaremos nuestra discusión sobre Vocabulario y
Concordancia de frases en Python.

Rate this post

Te puede interesar:

Python para la PNL: Comprender la palabra Depurar aplicaciones de Implementando LDA en

trabajar con la biblioteca clave "rendimiento" de Python con el módulo PDB Python con Scikit-Learn
FastText de Facebook Python

Python para PNL: Desarrollo de GUI en Tutorial para principiantes Regresión lineal en Python
generación de texto de Python con Tkinter: Parte 3 sobre la biblioteca Panda con Scikit-Learn
aprendizaje profundo con de Python
Keras
https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 14/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos
Keras

Cómo seleccionar Cómo iterar sobre filas en OpenGL avanzado en Python para PNL:
elementos aleatoriamente un marco de datos de Python con PyGame y Traducción automática
de una lista en Python Pandas PyOpenGL neuronal con Seq2Seq en
Keras

Etiquetas: python

Sobre mi

Ramiro de la Vega
Bienvenido a Pharos.sh

Soy Ramiro de la Vega, Estadounidense con raíces Españolas. Empecé a programar

hace casi 20 años cuando era muy jovencito.

Espero que en mi web encuentres la inspiración y ayuda que necesitas para

adentrarte en el fantástico mundo de la programación y conseguir tus objetivos por difíciles que sean.

Buscar …

Últimos Post
4 increíbles aplicaciones de Android para descargar vídeos de YouTube

El mito de la multitarea como desarrollador

Introducción al estilo de codificación Python

Tutorial de Python para principiantes absolutos

Algoritmo de bosque aleatorio con Python y Scikit-Learn

Preparación para una entrevista de trabajo como programador

El módulo de archivo temporal de Python

El algoritmo Naive Bayes en Python con Scikit-Learn

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 15/16
15/3/22, 13:20 ᐉ Python para PNL: tokenización, derivación y lematización con la biblioteca SpaCy | Pharos

Hapi vs Express: comparación de marcos web de Node.js

Implementación de PCA en Python con Scikit-Learn

Etiquetas
administración
algoritmos
angular
apache
api
base de datos
camuflaje
configure
código de ejemplo
Código de muestra
cómo

django
docker
entrevista
explicado
git
graphql
herramienta
incrustado
inteligencia artificial
intento
Java

javascript
Jenkins
json
linux
logstash
machine learning
margen
matplotlib
node
npm
phaser
python
revisión
Rápido
spring
sql
ssh
tensorflow
teoría
typescript
udemy
unix
vue

Contacto | Política de Privacidad | Política de Cookies

https://pharos.sh/python-para-pnl-tokenizacion-derivacion-y-lematizacion-con-la-biblioteca-spacy/ 16/16
15/3/22, 13:21 Tutorial: Quickstart — TextBlob 0.16.0 documentation

Tutorial: Quickstart
TextBlob aims to provide access to common text-processing operations through a familiar interface. You can treat
TextBlob objects as if they were Python strings that learned how to do Natural Language Processing.

Create a TextBlob
First, the import.

>>> from textblob import TextBlob

Let’s create our first TextBlob.

>>> wiki = TextBlob("Python is a high-level, general-purpose programming language.")

Part-of-speech Tagging ¶
Part-of-speech tags can be accessed through the tags property.

>>> wiki.tags

[('Python', 'NNP'), ('is', 'VBZ'), ('a', 'DT'), ('high-level', 'JJ'), ('general-purpose', 'JJ'), ('

Noun Phrase Extraction

Similarly, noun phrases are accessed through the noun_phrases property.

>>> wiki.noun_phrases

WordList(['python'])

Sentiment Analysis
The sentiment property returns a namedtuple of the form Sentiment(polarity, subjectivity). The polar-
ity score is a float within the range [-1.0, 1.0]. The subjectivity is a float within the range [0.0, 1.0] where 0.0 is very ob-
jective and 1.0 is very subjective.

>>> testimonial = TextBlob("Textblob is amazingly simple to use. What great fun!")

>>> testimonial.sentiment

Sentiment(polarity=0.39166666666666666, subjectivity=0.4357142857142857)

>>> testimonial.sentiment.polarity

0.39166666666666666

Tokenization
You can break TextBlobs into words or sentences.

>>> zen = TextBlob("Beautiful is better than ugly. "

... "Explicit is better than implicit. "

... "Simple is better than complex.")

>>> zen.words

WordList(['Beautiful', 'is', 'better', 'than', 'ugly', 'Explicit', 'is', 'better', 'than', 'implici
>>> zen.sentences

[Sentence("Beautiful is better than ugly."), Sentence("Explicit is better than implicit."), Sentenc

 
v: dev


Sentence objects have the same properties and methods as TextBlobs.

https://textblob.readthedocs.io/en/dev/quickstart.html#create-a-textblob 1/5
15/3/22, 13:21 Tutorial: Quickstart — TextBlob 0.16.0 documentation

>>> for sentence in zen.sentences:

... print(sentence.sentiment)

For more advanced tokenization, see the Advanced Usage guide.

Words Inflection and Lemmatization

Each word in TextBlob.words or Sentence.words is a Word
object (a subclass of unicode) with useful methods,
e.g. for word inflection.

>>> sentence = TextBlob('Use 4 spaces per indentation level.')

>>> sentence.words

WordList(['Use', '4', 'spaces', 'per', 'indentation', 'level'])

>>> sentence.words[2].singularize()

'space'

>>> sentence.words[-1].pluralize()

'levels'

Words can be lemmatized by calling the lemmatize method.

>>> from textblob import Word

>>> w = Word("octopi")
>>> w.lemmatize()

'octopus'

>>> w = Word("went")

>>> w.lemmatize("v") # Pass in WordNet part of speech (verb)

'go'

WordNet Integration
You can access the synsets for a Word via the synsets property or the get_synsets method, optionally passing in a
part of speech.

>>> from textblob import Word

>>> from textblob.wordnet import VERB

>>> word = Word("octopus")

>>> word.synsets

[Synset('octopus.n.01'), Synset('octopus.n.02')]

>>> Word("hack").get_synsets(pos=VERB)

[Synset('chop.v.05'), Synset('hack.v.02'), Synset('hack.v.03'), Synset('hack.v.04'), Synset('hack.v

You can access the definitions for each synset via the definitions property or the define() method, which can
also take an optional part-of-speech argument.

>>> Word("octopus").definitions

['tentacles of octopus prepared as food', 'bottom-living cephalopod having a soft oval body with ei

You can also create synsets directly.

>>> from textblob.wordnet import Synset

>>> octopus = Synset('octopus.n.02')

>>> shrimp = Synset('shrimp.n.03')

>>> octopus.path_similarity(shrimp)

0.1111111111111111

For more information on the WordNet API, see the NLTK documentation on the Wordnet Interface.
 
v: dev


WordLists
https://textblob.readthedocs.io/en/dev/quickstart.html#create-a-textblob 2/5
15/3/22, 13:21 Tutorial: Quickstart — TextBlob 0.16.0 documentation

A WordList is just a Python list with additional methods.

>>> animals = TextBlob("cat dog octopus")

>>> animals.words

WordList(['cat', 'dog', 'octopus'])

>>> animals.words.pluralize()

WordList(['cats', 'dogs', 'octopodes'])

Spelling Correction
Use the correct() method to attempt spelling correction.

>>> b = TextBlob("I havv goood speling!")

>>> print(b.correct())

I have good spelling!

Word objects have a spellcheck() Word.spellcheck() method that returns a list of (word, confidence)
tuples with spelling suggestions.

>>> from textblob import Word

>>> w = Word('falibility')

>>> w.spellcheck()

[('fallibility', 1.0)]

Spelling correction is based on Peter Norvig’s “How to Write a Spelling Corrector”[1] as implemented in the pattern li-
brary. It is about 70% accurate [2].

Get Word and Noun Phrase Frequencies

There are two ways to get the frequency of a word or noun phrase in a TextBlob.

The first is through the word_counts dictionary.

>>> monty = TextBlob("We are no longer the Knights who say Ni. "

... "We are now the Knights who say Ekki ekki ekki PTANG.")

>>> monty.word_counts['ekki']

If you access the frequencies this way, the search will not be case sensitive, and words that are not found will have a fre-
quency of 0.

The second way is to use the count() method.

>>> monty.words.count('ekki')

You can specify whether or not the search should be case-sensitive (default is False).

>>> monty.words.count('ekki', case_sensitive=True)

Each of these methods can also be used with noun phrases.

>>> wiki.noun_phrases.count('python')

Parsing  
v: dev


Use the parse() method to parse the text.

https://textblob.readthedocs.io/en/dev/quickstart.html#create-a-textblob 3/5
15/3/22, 13:21 Tutorial: Quickstart — TextBlob 0.16.0 documentation

>>> b = TextBlob("And now for something completely different.")

>>> print(b.parse())

And/CC/O/O now/RB/B-ADVP/O for/IN/B-PP/B-PNP something/NN/B-NP/I-PNP completely/RB/B-ADJP/O differe

By default, TextBlob uses pattern’s parser [3].

TextBlobs Are Like Python Strings!

You can use Python’s substring syntax.

>>> zen[0:19]

TextBlob("Beautiful is better")

You can use common string methods.

>>> zen.upper()

TextBlob("BEAUTIFUL IS BETTER THAN UGLY. EXPLICIT IS BETTER THAN IMPLICIT. SIMPLE IS BETTER THAN CO
>>> zen.find("Simple")

65

You can make comparisons between TextBlobs and strings.

>>> apple_blob = TextBlob('apples')

>>> banana_blob = TextBlob('bananas')

>>> apple_blob < banana_blob

True

>>> apple_blob == 'apples'

True

You can concatenate and interpolate TextBlobs and strings.

>>> apple_blob + ' and ' + banana_blob

TextBlob("apples and bananas")

>>> "{0} and {1}".format(apple_blob, banana_blob)

'apples and bananas'

n-grams
The TextBlob.ngrams() method returns a list of tuples of n successive words.

>>> blob = TextBlob("Now is better than never.")

>>> blob.ngrams(n=3)

[WordList(['Now', 'is', 'better']), WordList(['is', 'better', 'than']), WordList(['better', 'than',

Get Start and End Indices of Sentences

Use sentence.start and sentence.end to get the indices where a sentence starts and ends within a TextBlob.

>>> for s in zen.sentences:

... print(s)

... print("---- Starts at index {}, Ends at index {}".format(s.start, s.end))

Beautiful is better than ugly.

---- Starts at index 0, Ends at index 30

Explicit is better than implicit.

---- Starts at index 31, Ends at index 64

 
v: dev

Simple is better than complex.

---- Starts at index 65, Ends at index 95

https://textblob.readthedocs.io/en/dev/quickstart.html#create-a-textblob 4/5
15/3/22, 13:21 Tutorial: Quickstart — TextBlob 0.16.0 documentation

Next Steps
Want to build your own text classification system? Check out the Classifiers Tutorial.

Want to use a different POS tagger or noun phrase chunker implementation? Check out the Advanced Usage guide.

[1] http://norvig.com/spell-correct.html

[2] http://www.clips.ua.ac.be/pages/pattern-en#spelling

[3] http://www.clips.ua.ac.be/pages/pattern-en#parser

 
v: dev


https://textblob.readthedocs.io/en/dev/quickstart.html#create-a-textblob 5/5
3.1.1. Librerías y Paquetes de Python
 3.2. Leer un Dataset
#Use to import pandas

import pandas as pd
Cargar un .csv #Use to import the file into google Colab drive
desde colab de from google.colab import files

Google #Esto abrirá un widget cuando se ejecute que permitirá

#explorar los archivos de la unidad de almacenamiento.

uploaded = files.upload()

# Now use the below code to read the csv in pandas' dataframe
# df = pd.read_csv(io.StringIO(uploaded[‘f.csv'].decode('utf-8')))

df = pd.read_csv('equiposF.csv’,sep=‘,’,header=0)

print(df)
print(df.head())
print(df.ix[0:3])
print(df[‘Nombre’])
 3.2. Leer un Dataset

#En Visual Studio Code: aquí se pone la ruta de la capeta de donde esta el .csv a
Cargar .csv desde leerse.

diferentes import pandas as pd

df = pd.read_csv('E:/CICLO-2/IA/pandas/data.csv', index_col=0)
ambientes print(df)

#En Jupyter: aquí se pone la ruta de la capeta de donde esta el .csv a leerse.

import pandas as pd
df = pd.read_csv('E:/CICLO-2/IA/pandas/data.csv', index_col=0)
print(df)
 4.2.3 Regresión Lineal
Cinco pasos básicos para implementar la regresión lineal

1)Importar los paquetes y clases que se necesitan.

2)Proporcionar los datos para trabajar y eventualmente realizar las transformaciones apropiadas.
3)Crear un modelo de regresión y ajustarlo con los datos existentes.
4)Verificar los resultados del ajuste del modelo para saber si el modelo es satisfactorio.
5)Aplicar el modelo para predicciones.
 4.2. Aprendizaje Supervisado
Aquí lo que se busca, es la función que relaciona los datos de entrada, con los datos de salida; Si por ejemplo los
datos de entrada son caballos entonces buscamos las etiquetas de salida llamada “caballo”.

La idea es que esa función hallada a futuro sea capaz de reconocer cualquier entrada nueva que llegue.
 En el Aprendizaje Supervisado los datos para el
4.2. Aprendizaje Supervisado entrenamiento incluyen la solución deseada, llamada
«etiquetas» (labels).

Dataset

Característica Etiqueta
Área(m^2) Precio
234 600
C 125 500 Como se lo hace ?
a 421 200
s 250 500
a 320 600
s 431 700
520 800

modelo paramétrico
4.2. Aprendizaje Supervisado

Los algoritmos más utilizados : Un claro ejemplo es crear un

clasificador de correos entrantes entre
• k-Nearest Neighbors – Ejercicio en Python Spam y no Spam. Entre las diversas
• Linear Regression – Ejercicio Python paso a paso características que queremos entrenar
deberemos incluir si es correo basura o
• Logistic Regression – Ejemplo en Python no con un (1) o un (0). Otro ejemplo son
• Support Vector Machines predecir valores numéricos por ejemplo
precio de vivienda a partir de sus
• Bayesian Classifiers – Teoría y Ejemplo en Python características (metros cuadrados, nº de
• Decision Tress and Random Forest – Ejemplo árbol en español habitaciones, incluye calefacción,
distancia del centro, etc.) y deberemos
• Neural Networks – Ejemplo en Python con Keras en 15 líneas incluir el precio que averiguamos en
• Deep Learning nuestro set de datos.