Contenido

AI con Python - Conceptos básicos

AI con Python - Comenzando
AI con Python - Aprendizaje automático
AI con Python - Preparación de datos
Aprendizaje supervisado: clasificación
Aprendizaje supervisado: regresión
AI con Python - Programación lógica
Aprendizaje no supervisado: agrupamiento
Procesamiento natural del lenguaje
AI con Python - Paquete NLTK
Análisis de datos de series temporales
AI con Python - Reconocimiento de voz
AI con Python - Búsqueda heurística
AI con Python - Juegos
AI con Python - Redes neuronales
Aprendizaje reforzado
AI con Python - Algoritmos genéticos
AI con Python - Visión por computadora
AI con Python - Aprendizaje profundo
 AI con Python - Primer Concept
Desde la invención de las computadoras o máquinas, su capacidad para
realizar diversas tareas ha experimentado un crecimiento exponencial. Los
humanos han desarrollado el poder de los sistemas informáticos en términos
de sus diversos dominios de trabajo, su velocidad creciente y la reducción de
tamaño con respecto al tiempo.
Una rama de la informática llamada Inteligencia Artificial persigue la creación
de computadoras o máquinas tan inteligentes como los seres humanos.

Concepto Básico de Inteligencia Artificial (IA)

Según el padre de Inteligencia Artificial, John McCarthy, es "La ciencia y la
ingeniería de hacer máquinas inteligentes, especialmente programas
informáticos inteligentes".
La Inteligencia Artificial es una forma de hacer que una computadora, un robot
controlado por computadora o un software piensen de manera inteligente, de
la misma manera que piensan los humanos inteligentes. La IA se logra al
estudiar cómo piensa el cerebro humano y cómo los humanos aprenden,
deciden y trabajan mientras intentan resolver un problema, y luego usan los
resultados de este estudio como base para desarrollar software y sistemas
inteligentes.
Mientras explota el poder de los sistemas informáticos, la curiosidad del ser
humano lo lleva a preguntarse: "¿Puede una máquina pensar y comportarse
como lo hacen los humanos?"
Por lo tanto, el desarrollo de la IA comenzó con la intención de crear una
inteligencia similar en las máquinas que encontramos y consideramos alta en
los humanos.

La necesidad de aprender IA
Como sabemos, la IA persigue la creación de máquinas tan inteligentes como
los seres humanos. Existen numerosas razones para que estudiemos IA. Los
motivos son los siguientes:

AI puede aprender a través de datos

En nuestra vida diaria, tratamos con una gran cantidad de datos y el cerebro
humano no puede hacer un seguimiento de tanta información. Por eso
necesitamos automatizar las cosas. Para realizar la automatización,
necesitamos estudiar la IA porque puede aprender de los datos y puede
realizar las tareas repetitivas con precisión y sin cansancio.

La IA puede enseñarse sola

Es muy necesario que un sistema se enseñe solo porque los datos en sí

mismos cambian constantemente y el conocimiento que se deriva de dichos
datos debe actualizarse constantemente. Podemos usar IA para cumplir este
propósito porque un sistema habilitado para IA puede enseñarse solo.

La IA puede responder en tiempo real

La inteligencia artificial con la ayuda de redes neuronales puede analizar los

datos más profundamente. Debido a esta capacidad, AI puede pensar y
responder a las situaciones que se basan en las condiciones en tiempo real.

AI logra precisión

Con la ayuda de redes neuronales profundas, la IA puede lograr una precisión

tremenda. La IA ayuda en el campo de la medicina a diagnosticar
enfermedades como el cáncer de las IRM de los pacientes.

AI puede organizar los datos para aprovecharlos al máximo

Los datos son propiedad intelectual de los sistemas que utilizan algoritmos de
autoaprendizaje. Necesitamos AI para indexar y organizar los datos de
manera que siempre den los mejores resultados.

Entendiendo la inteligencia

Con AI, se pueden construir sistemas inteligentes. Necesitamos entender el

concepto de inteligencia para que nuestro cerebro pueda construir otro
sistema de inteligencia como él mismo.

¿Qué es la inteligencia?
La capacidad de un sistema para calcular, razonar, percibir relaciones y
analogías, aprender de la experiencia, almacenar y recuperar información de
la memoria, resolver problemas, comprender ideas complejas, usar el lenguaje
natural con fluidez, clasificar, generalizar y adaptar nuevas situaciones.

Tipos de inteligencia

Según lo descrito por Howard Gardner, un psicólogo del desarrollo

estadounidense, la inteligencia se presenta en múltiples formas:
www.postparaprogramadores.com
/
 No Inteligencia y descripción Ejemplo
Señor

1
Inteligencia lingüística
La capacidad de hablar, reconocer y usar mecanismos de Narradores, oradores
fonología (sonidos del habla), sintaxis (gramática) y
semántica (significado).

2
Inteligencia musical
La capacidad de crear, comunicarse y comprender Músicos, cantantes,
significados hechos de sonido, comprensión de tono, compositores
ritmo.

3
Inteligencia lógica-matemática
La capacidad de usar y comprender las relaciones en Matemáticos,
ausencia de acciones u objetos. También es la capacidad científicos
de comprender ideas complejas y abstractas.

44
Inteligencia espacial
La capacidad de percibir información visual o espacial, Lectores de mapas,
cambiarla y recrear imágenes visuales sin referencia a los astronautas, físicos
objetos, construir imágenes en 3D y moverlas y rotarlas.

55
Inteligencia corporal-kinestésica
La capacidad de usar todo o parte del cuerpo para
resolver problemas o productos de moda, controlar las Jugadores, bailarines
habilidades motoras finas y gruesas, y manipular los
objetos.

66
Inteligencia intrapersonal
La capacidad de distinguir entre los propios sentimientos, Gautam Buddhha
intenciones y motivaciones.

77
Inteligencia interpersonal Comunicadores de
La capacidad de reconocer y hacer distinciones entre los masas,
sentimientos, creencias e intenciones de otras personas. entrevistadores

Se puede decir que una máquina o un sistema es artificialmente inteligente

cuando está equipado con al menos una o todas las inteligencias que
contiene.
 Síguenos en Instagram para que estés al tanto de los
nuevos libros de programación. Click aqui

¿De qué está compuesta la inteligencia?

La inteligencia es intangible. Se compone de -

 Razonamiento
 Aprendizaje
 Resolución de problemas
 Percepción
 Inteligencia lingüística

Veamos brevemente todos los componentes:

Razonamiento

Es el conjunto de procesos que nos permiten proporcionar una base para el

juicio, la toma de decisiones y la predicción. En general, hay dos tipos:
 Razonamiento inductivo Razonamiento
deductivo

Comienza con
una
declaración
general y
Realiza observaciones específicas para hacer declaraciones generales examina las
amplias. posibilidades
de llegar a una
conclusión
específica y
lógica.

Incluso si todas las premisas son verdaderas en una declaración, el Si algo es

razonamiento inductivo permite que la conclusión sea falsa. cierto para una
clase de cosas
en general,
también es
cierto para
todos los
miembros de
esa clase.

Ejemplo :
"Todas las
mujeres
mayores de 60
Ejemplo : "Nita es maestra. Nita es estudiosa. Por lo tanto, todos los años son
maestros son estudiosos". abuelas.
Shalini tiene
65 años. Por lo
tanto, Shalini
es abuela".

Aprendizaje - l
Los humanos, las especies particulares de animales y los sistemas habilitados
para IA poseen la capacidad de aprender. El aprendizaje se clasifica de la
siguiente manera:

Aprendizaje auditivo

Es aprender escuchando y escuchando. Por ejemplo, estudiantes que

escuchan conferencias de audio grabadas.

Aprendizaje Episódico
Aprender recordando secuencias de eventos que uno ha presenciado o
experimentado. Esto es lineal y ordenado.

Aprendizaje motor

Está aprendiendo por el movimiento preciso de los músculos. Por ejemplo,

escoger objetos, escribir, etc.

Aprendizaje por observacion

Aprender observando e imitando a los demás. Por ejemplo, el niño trata de

aprender imitando a su padre.

Aprendizaje perceptivo

Está aprendiendo a reconocer los estímulos que uno ha visto antes. Por
ejemplo, identificar y clasificar objetos y situaciones.

Aprendizaje Relacional

Implica aprender a diferenciar entre varios estímulos sobre la base de

propiedades relacionales, en lugar de propiedades absolutas. Por ejemplo,
agregar "un poco menos" de sal al momento de cocinar las papas que salieron
saladas la última vez, cuando se cocinan agregando, digamos una cucharada
de sal.
 Aprendizaje espacial : es aprender a través de estímulos visuales como
imágenes, colores, mapas, etc. Por ejemplo, una persona puede crear una hoja
de ruta en mente antes de seguir la ruta.
 Aprendizaje de estímulo-respuesta : es aprender a realizar un comportamiento
particular cuando está presente un cierto estímulo. Por ejemplo, un perro levanta
la oreja al escuchar el timbre.

Resolución de problemas

Es el proceso en el cual uno percibe y trata de llegar a una solución deseada

de una situación presente tomando un camino que está bloqueado por
obstáculos conocidos o desconocidos.
La resolución de problemas también incluye la toma de decisiones , que es el
proceso de seleccionar la mejor alternativa adecuada entre múltiples
alternativas para alcanzar la meta deseada.

Percepción

Es el proceso de adquirir, interpretar, seleccionar y organizar información

sensorial.
La percepción supone sentir . En los humanos, la percepción es ayudada por
los órganos sensoriales. En el dominio de la IA, el mecanismo de percepción
reúne los datos adquiridos por los sensores de manera significativa.
Inteligencia lingüística

Es la habilidad de uno para usar, comprender, hablar y escribir el lenguaje

verbal y escrito. Es importante en la comunicación interpersonal.

¿Qué implica la IA?

La inteligencia artificial es un área extensa de estudio. Este campo de estudio
ayuda a encontrar soluciones a problemas del mundo real.
Veamos ahora los diferentes campos de estudio dentro de la IA:

Aprendizaje automático

Es uno de los campos más populares de IA. El concepto básico de este

archivo es hacer que la máquina aprenda de los datos como los seres
humanos pueden aprender de su experiencia. Contiene modelos de
aprendizaje sobre la base de los cuales se pueden hacer predicciones sobre
datos desconocidos.

Lógica

Es otro campo de estudio importante en el que se utiliza la lógica matemática

para ejecutar los programas informáticos. Contiene reglas y hechos para
realizar una coincidencia de patrones, análisis semántico, etc.

buscando

Este campo de estudio se usa básicamente en juegos como el ajedrez, el tic-

tac-toe. Los algoritmos de búsqueda dan la solución óptima después de
buscar en todo el espacio de búsqueda.

Redes neuronales artificiales

Esta es una red de sistemas informáticos eficientes cuyo tema central se toma
prestado de la analogía de las redes neuronales biológicas. ANN se puede
utilizar en robótica, reconocimiento de voz, procesamiento de voz, etc.

Algoritmo genético

Los algoritmos genéticos ayudan a resolver problemas con la asistencia de

más de un programa. El resultado se basaría en seleccionar el más apto.

Representación del conocimiento

Es el campo de estudio con la ayuda del cual podemos representar los hechos
de una manera que la máquina pueda entender. Cuanto más eficientemente
se representa el conocimiento; Cuanto más sistema sería inteligente.
Aplicación de IA
En esta sección, veremos los diferentes campos compatibles con AI:

Juego de azar

La IA desempeña un papel crucial en juegos estratégicos como el ajedrez, el

póker, el tic-tac-toe, etc., donde la máquina puede pensar en un gran número
de posibles posiciones basadas en el conocimiento heurístico.

Procesamiento natural del lenguaje

Es posible interactuar con la computadora que entiende el lenguaje natural

hablado por los humanos.

Sistemas expertos

Hay algunas aplicaciones que integran máquina, software e información

especial para impartir razonamiento y asesoramiento. Proporcionan
explicaciones y consejos a los usuarios.

Sistemas de vision

Estos sistemas entienden, interpretan y comprenden la información visual en

la computadora. Por ejemplo,
 Un avión espía toma fotografías, que se utilizan para descubrir información
espacial o un mapa de las áreas.
 Los médicos usan el sistema clínico experto para diagnosticar al paciente.
 La policía usa un software de computadora que puede reconocer la cara del
criminal con el retrato almacenado hecho por el artista forense.

Reconocimiento de voz

Algunos sistemas inteligentes son capaces de escuchar y comprender el

lenguaje en términos de oraciones y sus significados mientras un humano
habla con él. Puede manejar diferentes acentos, palabras de argot, ruido de
fondo, cambios en el ruido humano debido al frío, etc.

Reconocimiento de escritura a mano

El software de reconocimiento de escritura manual lee el texto escrito en papel

con un bolígrafo o en la pantalla con un lápiz óptico. Puede reconocer las
formas de las letras y convertirlas en texto editable.

Robots Inteligentes

Los robots pueden realizar las tareas asignadas por un humano. Tienen
sensores para detectar datos físicos del mundo real, como luz, calor,
temperatura, movimiento, sonido, golpes y presión. Tienen procesadores
eficientes, múltiples sensores y una gran memoria para exhibir
inteligencia. Además, son capaces de aprender de sus errores y pueden
adaptarse al nuevo entorno.

Modelado cognitivo: simulando procedimiento de

pensamiento humano
El modelado cognitivo es básicamente el campo de estudio dentro de la
informática que se ocupa del estudio y simula el proceso de pensamiento de
los seres humanos. La tarea principal de la IA es hacer que la máquina piense
como humana. La característica más importante del proceso de pensamiento
humano es la resolución de problemas. Es por eso que más o menos el
modelado cognitivo intenta comprender cómo los humanos pueden resolver
los problemas. Después de eso, este modelo se puede utilizar para diversas
aplicaciones de IA, como el aprendizaje automático, la robótica, el
procesamiento del lenguaje natural, etc. A continuación se muestra el
diagrama de diferentes niveles de pensamiento del cerebro humano:

Agente y medio ambiente

En esta sección, nos centraremos en el agente y el entorno y cómo estos
ayudan en la Inteligencia Artificial.

Agente

Un agente es cualquier cosa que puede percibir su entorno a través de

sensores y actúa sobre ese entorno a través de efectores.
 Un agente humano tiene órganos sensoriales como ojos, oídos, nariz, lengua y
piel paralelos a los sensores, y otros órganos como manos, piernas, boca, para
efectores.
  Un agente robótico reemplaza cámaras y buscadores de rango infrarrojo para los
sensores, y varios motores y actuadores para efectores.
 Un agente de software ha codificado cadenas de bits como sus programas y
acciones.

Ambiente

Algunos programas operan en un entorno completamente artificial limitado a

la entrada del teclado, la base de datos, los sistemas de archivos de
computadora y la salida de caracteres en una pantalla.
En contraste, algunos agentes de software (robots de software o softbots)
existen en dominios de softbots ricos e ilimitados. El simulador tiene
un entorno complejo muy detallado . El agente de software debe elegir
entre una gran variedad de acciones en tiempo real. Un softbot está diseñado
para escanear las preferencias en línea del cliente y muestra elementos
interesantes para que el cliente trabaje en un entorno real y artificial .

AI con Python - Comenzando

En este capítulo, aprenderemos cómo comenzar con Python. También
entenderemos cómo Python ayuda para la Inteligencia Artificial.

Por qué Python para AI

La inteligencia artificial se considera la tecnología de tendencia del futuro. Ya
hay una serie de aplicaciones realizadas en él. Debido a esto, muchas
empresas e investigadores se están interesando en él. Pero la pregunta
principal que surge aquí es en qué lenguaje de programación se pueden
desarrollar estas aplicaciones de IA. Existen varios lenguajes de programación
como Lisp, Prolog, C ++, Java y Python, que se pueden usar para desarrollar
aplicaciones de IA. Entre ellos, el lenguaje de programación Python gana una
gran popularidad y las razones son las siguientes:

Sintaxis simple y menos codificación

Python implica muy poca codificación y sintaxis simple entre otros lenguajes
de programación que se pueden usar para desarrollar aplicaciones de
IA. Debido a esta característica, la prueba puede ser más fácil y podemos
centrarnos más en la programación.

Bibliotecas incorporadas para proyectos de IA

Una gran ventaja de usar Python para AI es que viene con bibliotecas
incorporadas. Python tiene bibliotecas para casi todo tipo de proyectos de
IA. Por ejemplo, NumPy, SciPy, matplotlib, nltk, SimpleAI son algunas de
las bibliotecas incorporadas importantes de Python.
 Código abierto : Python es un lenguaje de programación de código abierto. Esto
lo hace muy popular en la comunidad.
  Se puede usar para una amplia gama de programación : Python se puede usar
para una amplia gama de tareas de programación, como un pequeño script de
shell para aplicaciones web empresariales. Esta es otra razón por la que Python
es adecuado para proyectos de IA.

Características de Python
Python es un lenguaje de scripting de alto nivel, interpretado, interactivo y
orientado a objetos. Python está diseñado para ser altamente legible. Utiliza
palabras clave en inglés con frecuencia, mientras que otros idiomas usan
signos de puntuación, y tiene menos construcciones sintácticas que otros
idiomas. Las características de Python incluyen lo siguiente:
 Fácil de aprender : Python tiene pocas palabras clave, estructura simple y una
sintaxis claramente definida. Esto le permite al alumno aprender el idioma
rápidamente.
 Fácil de leer : el código de Python está más claramente definido y visible para los
ojos.
 Fácil de mantener : el código fuente de Python es bastante fácil de mantener.
 Una biblioteca estándar amplia : la mayor parte de la biblioteca de Python es
muy portátil y compatible con plataformas cruzadas en UNIX, Windows y
Macintosh.
 Modo interactivo : Python admite un modo interactivo que permite realizar
pruebas interactivas y depurar fragmentos de código.
 Portátil : Python puede ejecutarse en una amplia variedad de plataformas de
hardware y tiene la misma interfaz en todas las plataformas.
 Extensible : podemos agregar módulos de bajo nivel al intérprete de
Python. Estos módulos permiten a los programadores agregar o personalizar sus
herramientas para ser más eficientes.
 Bases de datos : Python proporciona interfaces a todas las principales bases de
datos comerciales.
 Programación GUI : Python admite aplicaciones GUI que se pueden crear y
portar a muchas llamadas de sistema, bibliotecas y sistemas Windows, como
Windows MFC, Macintosh y el sistema X Window de Unix.
 Escalable : Python proporciona una mejor estructura y soporte para programas
grandes que los scripts de shell.

Características importantes de Python

Consideremos ahora las siguientes características importantes de Python:

 Admite métodos de programación funcionales y estructurados, así como OOP.
 Se puede usar como un lenguaje de scripting o se puede compilar en código de
bytes para construir aplicaciones grandes.
 Proporciona tipos de datos dinámicos de muy alto nivel y admite la verificación de
tipos dinámicos.
 Es compatible con la recolección automática de basura.
 Se puede integrar fácilmente con C, C ++, COM, ActiveX, CORBA y Java.
Instalando Python
La distribución de Python está disponible para una gran cantidad de
plataformas. Necesita descargar solo el código binario aplicable a su
plataforma e instalar Python.
Si el código binario para su plataforma no está disponible, necesita un
compilador de C para compilar el código fuente manualmente. Compilar el
código fuente ofrece más flexibilidad en cuanto a la elección de las
características que necesita en su instalación.
Aquí hay una descripción rápida de la instalación de Python en varias
plataformas:

Instalación de Unix y Linux

Siga estos pasos para instalar Python en la máquina Unix / Linux.

 Abra un navegador web y vaya a https://www.python.org/downloads
 Siga el enlace para descargar el código fuente comprimido disponible para Unix /
Linux.
 Descargar y extraer archivos.
 Edición del archivo Módulos / Configuración si desea personalizar algunas
opciones.
 ejecute ./configure script
 hacer
 hacer instalar
Esto instala Python en la ubicación estándar / usr / local / bin y sus bibliotecas
en / usr / local / lib / pythonXX donde XX es la versión de Python.

Instalación de ventanas

Siga estos pasos para instalar Python en la máquina con Windows.

 Abra un navegador web y vaya a https://www.python.org/downloads
 Siga el enlace para el archivo .msi python-XYZ del instalador de Windows donde
XYZ es la versión que necesita instalar.
 Para usar este instalador python-XYZ .msi, el sistema Windows debe ser
compatible con Microsoft Installer 2.0. Guarde el archivo de instalación en su
máquina local y luego ejecútelo para averiguar si su máquina es compatible con
MSI.
 Ejecute el archivo descargado. Esto muestra el asistente de instalación de Python,
que es realmente fácil de usar. Simplemente acepte la configuración
predeterminada y espere hasta que finalice la instalación.

Instalación de Macintosh
Si está utilizando Mac OS X, se recomienda que utilice Homebrew para
instalar Python 3. Es un excelente instalador de paquetes para Mac OS X y es
realmente fácil de usar. Si no tiene Homebrew, puede instalarlo con el
siguiente comando:
$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/ins
tall)"
Podemos actualizar el administrador de paquetes con el siguiente comando:
$ brew update
Ahora ejecute el siguiente comando para instalar Python3 en su sistema:
$ brew install python3

Configurar RUTA
Los programas y otros archivos ejecutables pueden estar en muchos
directorios, por lo que los sistemas operativos proporcionan una ruta de
búsqueda que enumera los directorios que el sistema operativo busca
ejecutables.
La ruta se almacena en una variable de entorno, que es una cadena con
nombre mantenida por el sistema operativo. Esta variable contiene
información disponible para el shell de comandos y otros programas.
La variable de ruta se denomina RUTA en Unix o Ruta en Windows (Unix
distingue entre mayúsculas y minúsculas; Windows no).
En Mac OS, el instalador maneja los detalles de la ruta. Para invocar al
intérprete de Python desde cualquier directorio en particular, debe agregar el
directorio de Python a su ruta.

Configuración de ruta en Unix / Linux

Para agregar el directorio de Python a la ruta de una sesión en particular en

Unix:
 En la csh shell
Escriba setenv PATH "$ PATH: / usr / local / bin / python" y presione Entrar .
 En el shell bash (Linux)
Escriba export ATH = "$ PATH: / usr / local / bin / python" y presione Entrar .
 En la cáscara sh o ksh
Escriba PATH = "$ PATH: / usr / local / bin / python" y presione Entrar .
Nota : / usr / local / bin / python es la ruta del directorio de Python.

Establecer ruta en Windows

Para agregar el directorio de Python a la ruta de una sesión en particular en

Windows:
  En el símbolo del sistema , escriba path% path%; C: \ Python y
presione Entrar .
Nota : C: \ Python es la ruta del directorio de Python.

Corriendo Python
Veamos ahora las diferentes formas de ejecutar Python. Las formas se
describen a continuación:

Intérprete interactivo

Podemos iniciar Python desde Unix, DOS o cualquier otro sistema que le
proporcione un intérprete de línea de comandos o una ventana de shell.
 Ingrese python en la línea de comando.
 Comience a codificar de inmediato en el intérprete interactivo.
$python # Unix/Linux
o
python% # Unix/Linux
o
C:> python # Windows/DOS
Aquí está la lista de todas las opciones de línea de comando disponibles:

S.No. Opción y descripción

1
-re
Proporciona resultados de depuración.

2
-o
Genera bytecode optimizado (que resulta en archivos .pyo).

3
-S
No ejecute el sitio de importación para buscar rutas de Python en el inicio.

44
-v
Salida detallada (rastreo detallado en las declaraciones de importación).

55
-X
Deshabilita las excepciones incorporadas basadas en la clase (solo use
cadenas); obsoleto a partir de la versión 1.6.
66
-c cmd
Ejecuta el script Python enviado como una cadena cmd.

77
Archivo
Ejecute el script Python desde el archivo dado.

Script desde la línea de comando

Un script de Python se puede ejecutar en la línea de comando invocando al
intérprete en su aplicación, como se muestra a continuación:
$python script.py # Unix/Linux
o,
python% script.py # Unix/Linux
o,
C:> python script.py # Windows/DOS
Nota : asegúrese de que el modo de permiso de archivo permita la ejecución.

Entorno de desarrollo integrado

También puede ejecutar Python desde un entorno de interfaz gráfica de
usuario (GUI), si tiene una aplicación GUI en su sistema que admita Python.
 Unix : IDLE es el primer IDE de Unix para Python.
 Windows : PythonWin es la primera interfaz de Windows para Python y es un IDE
con una GUI.
 Macintosh : la versión Macintosh de Python junto con IDLE IDE está disponible en
el sitio web principal, descargable como archivos MacBinary o BinHex'd.
Si no puede configurar el entorno correctamente, puede pedir ayuda al
administrador del sistema. Asegúrese de que el entorno de Python esté
configurado correctamente y funcione perfectamente bien.
También podemos usar otra plataforma Python llamada Anaconda. Incluye
cientos de paquetes populares de ciencia de datos y el paquete conda y el
administrador de entorno virtual para Windows, Linux y MacOS. Puede
descargarlo según su sistema operativo desde el
enlace https://www.anaconda.com/download/ .
Para este tutorial estamos usando la versión Python 3.6.3 en MS Windows.

AI con Python - Aprendizaje automático

Aprender significa la adquisición de conocimientos o habilidades a través del
estudio o la experiencia. En base a esto, podemos definir el aprendizaje
automático (ML) de la siguiente manera:
Puede definirse como el campo de la informática, más específicamente una
aplicación de inteligencia artificial, que proporciona a los sistemas informáticos
la capacidad de aprender con datos y mejorar de la experiencia sin ser
programados explícitamente.
Básicamente, el enfoque principal del aprendizaje automático es permitir que
las computadoras aprendan automáticamente sin intervención humana. Ahora
surge la pregunta de cómo se puede comenzar y hacer tal aprendizaje. Se
puede comenzar con las observaciones de datos. Los datos pueden ser
algunos ejemplos, instrucciones o algunas experiencias directas
también. Luego, sobre la base de esta entrada, la máquina toma una mejor
decisión al buscar algunos patrones en los datos.

Tipos de aprendizaje automático (ML)

Los algoritmos de aprendizaje automático ayudan a los sistemas informáticos
a aprender sin ser programados explícitamente. Estos algoritmos se clasifican
en supervisados o no supervisados. Veamos ahora algunos algoritmos:

Algoritmos supervisados de aprendizaje automático

Este es el algoritmo de aprendizaje automático más utilizado. Se llama

supervisado porque el proceso de aprendizaje de algoritmos del conjunto de
datos de capacitación puede considerarse como un maestro que supervisa el
proceso de aprendizaje. En este tipo de algoritmo de ML, los posibles
resultados ya se conocen y los datos de entrenamiento también se etiquetan
con las respuestas correctas. Se puede entender de la siguiente manera:
Supongamos que tenemos variables de entrada x y una variable de salida y y
aplicamos un algoritmo para aprender la función de mapeo de la entrada a la
salida, como -
Y = f(x)
Ahora, el objetivo principal es aproximar la función de mapeo tan bien que
cuando tengamos nuevos datos de entrada (x), podamos predecir la variable
de salida (Y) para esos datos.
Los problemas de inclinación principalmente supervisados se pueden dividir
en los siguientes dos tipos de problemas:
 Clasificación : un problema se llama problema de clasificación cuando tenemos el
resultado categorizado como "negro", "enseñanza", "no enseñanza", etc.
 Regresión : un problema se llama problema de regresión cuando tenemos la
salida de valor real, como "distancia", "kilogramo", etc.
Árbol de decisión, bosque aleatorio, knn, regresión logística son ejemplos de
algoritmos supervisados de aprendizaje automático.

Algoritmos de aprendizaje automático no supervisados

Como su nombre lo indica, este tipo de algoritmos de aprendizaje automático

no tienen ningún supervisor para proporcionar ningún tipo de orientación. Es
por eso que los algoritmos de aprendizaje automático no supervisados están
estrechamente alineados con lo que algunos llaman verdadera inteligencia
artificial. Se puede entender de la siguiente manera:
Supongamos que tenemos una variable de entrada x, entonces no habrá
variables de salida correspondientes como en los algoritmos de aprendizaje
supervisados.
En palabras simples, podemos decir que en el aprendizaje no supervisado no
habrá una respuesta correcta y ningún maestro para la orientación. Los
algoritmos ayudan a descubrir patrones interesantes en los datos.
Los problemas de aprendizaje no supervisados se pueden dividir en los
siguientes dos tipos de problemas:
 Agrupación : en los problemas de agrupación, necesitamos descubrir las
agrupaciones inherentes en los datos. Por ejemplo, agrupar clientes por su
comportamiento de compra.
 Asociación : un problema se llama problema de asociación porque este tipo de
problema requiere descubrir las reglas que describen grandes porciones de
nuestros datos. Por ejemplo, encontrar los clientes que compran tanto x como y .
Los medios K para la agrupación, el algoritmo Apriori para la asociación son
ejemplos de algoritmos de aprendizaje automático no supervisados.

Refuerzo de algoritmos de aprendizaje automático

Este tipo de algoritmos de aprendizaje automático se usan muy poco. Estos

algoritmos entrenan a los sistemas para tomar decisiones
específicas. Básicamente, la máquina está expuesta a un entorno en el que se
entrena continuamente utilizando el método de prueba y error. Estos
algoritmos aprenden de la experiencia pasada y tratan de capturar el mejor
conocimiento posible para tomar decisiones precisas. El Proceso de decisión
de Markov es un ejemplo de algoritmos de aprendizaje automático de
refuerzo.

Algoritmos de aprendizaje automático más comunes

En esta sección, aprenderemos sobre los algoritmos de aprendizaje
automático más comunes. Los algoritmos se describen a continuación:

Regresión lineal

Es uno de los algoritmos más conocidos en estadística y aprendizaje

automático.
Concepto básico: principalmente la regresión lineal es un modelo lineal que
supone una relación lineal entre las variables de entrada, digamos x, y la
variable de salida única, digamos y. En otras palabras, podemos decir que y
puede calcularse a partir de una combinación lineal de las variables de
entrada x. La relación entre variables se puede establecer ajustando una
mejor línea.
Tipos de regresión lineal

La regresión lineal es de los siguientes dos tipos:

 Regresión lineal simple : un algoritmo de regresión lineal se denomina regresión
lineal simple si solo tiene una variable independiente.
 Regresión lineal múltiple : un algoritmo de regresión lineal se denomina
regresión lineal múltiple si tiene más de una variable independiente.
La regresión lineal se usa principalmente para estimar los valores reales
basados en variables continuas. Por ejemplo, la venta total de una tienda en
un día, basada en valores reales, puede estimarse por regresión lineal.

Regresión logística

Es un algoritmo de clasificación y también conocido como regresión logit .

Principalmente, la regresión logística es un algoritmo de clasificación que se
utiliza para estimar los valores discretos como 0 o 1, verdadero o falso, sí o no
en función de un conjunto dado de variables independientes. Básicamente,
predice la probabilidad, por lo tanto, su salida se encuentra entre 0 y 1.

Árbol de decisión

El árbol de decisión es un algoritmo de aprendizaje supervisado que se usa

principalmente para problemas de clasificación.
Básicamente es un clasificador expresado como partición recursiva basada en
las variables independientes. El árbol de decisión tiene nodos que forman el
árbol enraizado. El árbol enraizado es un árbol dirigido con un nodo llamado
"raíz". La raíz no tiene bordes entrantes y todos los demás nodos tienen un
borde entrante. Estos nodos se llaman hojas o nodos de decisión. Por
ejemplo, considere el siguiente árbol de decisión para ver si una persona está
en forma o no.

Máquina de vectores de soporte (SVM)

Se utiliza para problemas de clasificación y regresión. Pero principalmente se

usa para problemas de clasificación. El concepto principal de SVM es trazar
cada elemento de datos como un punto en el espacio n-dimensional con el
valor de cada entidad como el valor de una coordenada particular. Aquí n
serían las características que tendríamos. A continuación se presenta una
representación gráfica simple para comprender el concepto de SVM:
En el diagrama anterior, tenemos dos características, por lo tanto, primero
tenemos que trazar estas dos variables en un espacio bidimensional donde
cada punto tiene dos coordenadas, llamadas vectores de soporte. La línea
divide los datos en dos grupos clasificados diferentes. Esta línea sería el
clasificador.

Naïve Bayes

También es una técnica de clasificación. La lógica detrás de esta técnica de

clasificación es usar el teorema de Bayes para construir clasificadores. La
suposición es que los predictores son independientes. En palabras simples, se
supone que la presencia de una característica particular en una clase no está
relacionada con la presencia de ninguna otra característica. A continuación se
muestra la ecuación para el teorema de Bayes:
$$ P \ left (\ frac {A} {B} \ right) = \ frac {P \ left (\ frac {B} {A} \ right) P \ left (A \
right)} {P \ left ( B \ derecha)} $$
El modelo Naïve Bayes es fácil de construir y particularmente útil para grandes
conjuntos de datos.

Vecinos K-más cercanos (KNN)

Se utiliza tanto para la clasificación como para la regresión de los

problemas. Es ampliamente utilizado para resolver problemas de
clasificación. El concepto principal de este algoritmo es que solía almacenar
todos los casos disponibles y clasifica los casos nuevos por mayoría de votos
de sus k vecinos. El caso se asigna a la clase que es la más común entre sus
vecinos más cercanos a K, medida por una función de distancia. La función de
distancia puede ser Euclidiana, Minkowski y Hamming. Considere lo siguiente
para usar KNN:
 Computacionalmente, los KNN son caros que otros algoritmos utilizados para
problemas de clasificación.
 La normalización de las variables necesarias, de lo contrario, las variables de
rango más alto pueden sesgarlo.
 En KNN, necesitamos trabajar en la etapa de preprocesamiento, como la
eliminación de ruido.
Agrupamiento de medias K

Como su nombre indica, se utiliza para resolver los problemas de

agrupamiento. Básicamente es un tipo de aprendizaje no supervisado. La
lógica principal del algoritmo de agrupación de K-Means es clasificar el
conjunto de datos a través de varios grupos. Siga estos pasos para formar
grupos por medios K:
 K-means selecciona k número de puntos para cada grupo conocido como
centroides.
 Ahora cada punto de datos forma un grupo con los centroides más cercanos, es
decir, k grupos.
 Ahora, encontrará los centroides de cada grupo en función de los miembros del
grupo existentes.
 Necesitamos repetir estos pasos hasta que ocurra la convergencia.

Bosque al azar

Es un algoritmo de clasificación supervisado. La ventaja del algoritmo de

bosque aleatorio es que puede usarse para problemas de clasificación y
regresión. Básicamente es la colección de árboles de decisión (es decir,
bosque) o se puede decir conjunto de los árboles de decisión. El concepto
básico de bosque aleatorio es que cada árbol da una clasificación y el bosque
elige las mejores clasificaciones de ellos. Las siguientes son las ventajas del
algoritmo Random Forest:
 El clasificador de bosque aleatorio se puede usar para tareas de clasificación y
regresión.
 Pueden manejar los valores faltantes.
 No se ajustará demasiado al modelo, incluso si tenemos más árboles en el
bosque.

AI con Python - Preparación de datos

Ya hemos estudiado algoritmos de aprendizaje automático supervisados y no
supervisados. Estos algoritmos requieren datos formateados para comenzar el
proceso de capacitación. Debemos preparar o formatear los datos de cierta
manera para que puedan ser suministrados como entrada a los algoritmos de
ML.
Este capítulo se centra en la preparación de datos para algoritmos de
aprendizaje automático.

Preprocesando los datos

En nuestra vida diaria, tratamos con muchos datos, pero estos datos están en
forma cruda. Para proporcionar los datos como la entrada de algoritmos de
aprendizaje automático, necesitamos convertirlos en datos significativos. Ahí
es donde entra en escena el preprocesamiento de datos. En otras palabras
simples, podemos decir que antes de proporcionar los datos a los algoritmos
de aprendizaje automático, necesitamos preprocesar los datos.

Pasos de preprocesamiento de datos

Siga estos pasos para preprocesar los datos en Python:

Paso 1: Importar los paquetes útiles : si estamos usando Python, este sería
el primer paso para convertir los datos a un formato determinado, es decir, el
preprocesamiento. Se puede hacer de la siguiente manera:
import numpy as np
import sklearn.preprocessing
Aquí hemos utilizado los siguientes dos paquetes:
 NumPy : Básicamente, NumPy es un paquete de procesamiento de matriz de uso
general diseñado para manipular eficientemente grandes matrices
multidimensionales de registros arbitrarios sin sacrificar demasiada velocidad por
las matrices multidimensionales pequeñas.
 Sklearn.preprocessing : este paquete proporciona muchas funciones de utilidad
comunes y clases de transformador para cambiar los vectores de características
sin formato en una representación más adecuada para los algoritmos de
aprendizaje automático.
Paso 2: definición de datos de muestra : después de importar los paquetes,
necesitamos definir algunos datos de muestra para poder aplicar técnicas de
preprocesamiento en esos datos. Ahora definiremos los siguientes datos de
muestra:
Input_data = np.array([2.1, -1.9, 5.5],
[-1.5, 2.4, 3.5],
[0.5, -7.9, 5.6],
[5.9, 2.3, -5.8])
Paso 3: aplicación de la técnica de preprocesamiento : en este paso,
debemos aplicar cualquiera de las técnicas de preprocesamiento.
La siguiente sección describe las técnicas de preprocesamiento de datos.

Técnicas para el preprocesamiento de datos

Las técnicas para el preprocesamiento de datos se describen a continuación:

Binarización

Esta es la técnica de preprocesamiento que se utiliza cuando necesitamos

convertir nuestros valores numéricos en valores booleanos. Podemos usar un
método incorporado para binarizar los datos de entrada, por ejemplo, usando
0.5 como valor umbral de la siguiente manera:
data_binarized = preprocessing.Binarizer(threshold =
0.5).transform(input_data)
print("\nBinarized data:\n", data_binarized)
Ahora, después de ejecutar el código anterior, obtendremos el siguiente
resultado, todos los valores superiores a 0.5 (valor umbral) se convertirán a 1
y todos los valores inferiores a 0.5 se convertirán a 0.
Datos binarizados
[[ 1. 0. 1.]
[ 0. 1. 1.]
[ 0. 0. 1.]
[ 1. 1. 0.]]

Remoción media

Es otra técnica de preprocesamiento muy común que se utiliza en el

aprendizaje automático. Básicamente se usa para eliminar la media del vector
de características para que cada característica se centre en cero. También
podemos eliminar el sesgo de las características en el vector de
características. Para aplicar la técnica de preprocesamiento de eliminación
media en los datos de muestra, podemos escribir el código Python que se
muestra a continuación. El código mostrará la desviación media y estándar de
los datos de entrada:
print("Mean = ", input_data.mean(axis = 0))
print("Std deviation = ", input_data.std(axis = 0))
Obtendremos el siguiente resultado después de ejecutar las líneas de código
anteriores:
Mean = [ 1.75 -1.275 2.2]
Std deviation = [ 2.71431391 4.20022321 4.69414529]
Ahora, el siguiente código eliminará la desviación media y estándar de los
datos de entrada:
data_scaled = preprocessing.scale(input_data)
print("Mean =", data_scaled.mean(axis=0))
print("Std deviation =", data_scaled.std(axis = 0))
Obtendremos el siguiente resultado después de ejecutar las líneas de código
anteriores:
Mean = [ 1.11022302e-16 0.00000000e+00
0.00000000e+00]
Std deviation = [ 1. 1. 1.]

Escalada

Es otra técnica de preprocesamiento de datos que se utiliza para escalar los

vectores de características. La escala de los vectores de características es
necesaria porque los valores de cada característica pueden variar entre
muchos valores aleatorios. En otras palabras, podemos decir que la escala es
importante porque no queremos que ninguna característica sea sintéticamente
grande o pequeña. Con la ayuda del siguiente código de Python, podemos
escalar nuestros datos de entrada, es decir, el vector de características:
# Escala mínima máxima
data_scaler_minmax =
preprocessing.MinMaxScaler(feature_range=(0,1))
data_scaled_minmax =
data_scaler_minmax.fit_transform(input_data)
print ("\nMin max scaled data:\n", data_scaled_minmax)

Obtendremos el siguiente resultado después de ejecutar las líneas de código

anteriores:
Datos máximos mínimos escalados
[ [ 0.48648649 0.58252427 0.99122807]
[ 0. 1. 0.81578947]
[ 0.27027027 0. 1. ]
[ 1. 0. 99029126 0. ]]

Normalización

Es otra técnica de preprocesamiento de datos que se utiliza para modificar los

vectores de características. Este tipo de modificación es necesaria para medir
los vectores de características en una escala común. Los siguientes son dos
tipos de normalización que se pueden usar en el aprendizaje automático:
Normalización L1
También se conoce como desviaciones menos absolutas . Este tipo de
normalización modifica los valores para que la suma de los valores absolutos
siempre sea hasta 1 en cada fila. Se puede implementar en los datos de
entrada con la ayuda del siguiente código de Python:
# Normalize data
data_normalized_l1 = preprocessing.normalize(input_data, norm
= 'l1')
print("\nL1 normalized data:\n", data_normalized_l1)
La línea de código anterior genera el siguiente resultado & miuns;
L1 normalized data:
[[ 0.22105263 -0.2 0.57894737]
[ -0.2027027 0.32432432 0.47297297]
[ 0.03571429 -0.56428571 0.4 ]
[ 0.42142857 0.16428571 -0.41428571]]
Normalización L2
También se conoce como mínimos cuadrados . Este tipo de normalización
modifica los valores para que la suma de los cuadrados sea siempre 1 en
cada fila. Se puede implementar en los datos de entrada con la ayuda del
siguiente código de Python:
# Normalize data
data_normalized_l2 = preprocessing.normalize(input_data, norm
= 'l2')
print("\nL2 normalized data:\n", data_normalized_l2)
La línea de código anterior generará el siguiente resultado:
L2 normalized data:
[[ 0.33946114 -0.30713151 0.88906489]
[ -0.33325106 0.53320169 0.7775858 ]
[ 0.05156558 -0.81473612 0.57753446]
[ 0.68706914 0.26784051 -0.6754239 ]]

Etiquetando los datos

Ya sabemos que los datos en cierto formato son necesarios para los
algoritmos de aprendizaje automático. Otro requisito importante es que los
datos deben etiquetarse correctamente antes de enviarlos como entrada de
algoritmos de aprendizaje automático. Por ejemplo, si hablamos de
clasificación, hay muchas etiquetas en los datos. Esas etiquetas están en
forma de palabras, números, etc. Las funciones relacionadas con el
aprendizaje automático en sklearn esperan que los datos deben tener
etiquetas de números. Por lo tanto, si los datos están en otra forma, entonces
deben convertirse a números. Este proceso de transformar las etiquetas de
palabras en forma numérica se denomina codificación de etiquetas.

Pasos de codificación de etiquetas

Siga estos pasos para codificar las etiquetas de datos en Python:

Paso 1 - Importar los paquetes útiles
Si estamos usando Python, este sería el primer paso para convertir los datos a
cierto formato, es decir, el preprocesamiento. Se puede hacer de la siguiente
manera:
import numpy as np
from sklearn import preprocessing
Paso 2: definición de etiquetas de muestra
Después de importar los paquetes, necesitamos definir algunas etiquetas de
muestra para que podamos crear y entrenar el codificador de etiquetas. Ahora
definiremos las siguientes etiquetas de muestra:
# Sample input labels
input_labels =
['red','black','red','green','black','yellow','white']
Paso 3: creación y capacitación del objeto codificador de etiquetas
En este paso, necesitamos crear el codificador de etiquetas y entrenarlo. El
siguiente código de Python ayudará a hacer esto:
# Creating the label encoder
encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)
El siguiente sería el resultado después de ejecutar el código Python anterior:
LabelEncoder()
Paso 4: comprobación del rendimiento mediante la codificación de una
lista ordenada aleatoria
Este paso se puede utilizar para verificar el rendimiento codificando la lista
ordenada al azar. El siguiente código de Python se puede escribir para hacer
lo mismo:
# encoding a set of labels
test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)
Las etiquetas se imprimirían de la siguiente manera:
Labels = ['green', 'red', 'black']
Ahora, podemos obtener la lista de valores codificados, es decir, etiquetas de
palabras convertidas en números de la siguiente manera:
print("Encoded values =", list(encoded_values))

Los valores codificados se imprimirían de la siguiente manera:

Encoded values = [1, 2, 0]
Paso 5: verificar el rendimiento decodificando un conjunto aleatorio de
números:
Este paso se puede utilizar para verificar el rendimiento decodificando el
conjunto aleatorio de números. El siguiente código de Python se puede
escribir para hacer lo mismo:
# decoding a set of values
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)
print("\nEncoded values =", encoded_values)
Ahora, los valores codificados se imprimirían de la siguiente manera:
Encoded values = [3, 0, 4, 1]
print("\nDecoded labels =", list(decoded_list))
Ahora, los valores decodificados se imprimirían de la siguiente manera:
Decoded labels = ['white', 'black', 'yellow', 'green']

Datos etiquetados v / s sin etiquetar

Los datos no etiquetados consisten principalmente en muestras de objetos

naturales o creados por humanos que pueden obtenerse fácilmente del
mundo. Incluyen audio, video, fotos, artículos de noticias, etc.
Por otro lado, los datos etiquetados toman un conjunto de datos no
etiquetados y aumenta cada parte de esos datos sin etiquetar con alguna
etiqueta o etiqueta o clase que sea significativa. Por ejemplo, si tenemos una
foto, la etiqueta se puede poner en función del contenido de la foto, es decir,
es la foto de un niño o niña o animal o cualquier otra cosa. Etiquetar los datos
necesita experiencia o juicio humano sobre una determinada pieza de datos
sin etiquetar.
Hay muchos escenarios en los que los datos no etiquetados son abundantes y
fáciles de obtener, pero los datos etiquetados a menudo requieren un humano
/ experto para anotar. El aprendizaje semi-supervisado intenta combinar datos
etiquetados y no etiquetados para construir mejores modelos.

AI con Python - Aprendizaje supervisado:

clasificación
En este capítulo, nos enfocaremos en implementar el aprendizaje supervisado
- clasificación.
La técnica o modelo de clasificación intenta obtener alguna conclusión de los
valores observados. En el problema de clasificación, tenemos la salida
categorizada como "Negro" o "blanco" o "Enseñanza" y "No
enseñanza". Mientras construimos el modelo de clasificación, necesitamos
tener un conjunto de datos de entrenamiento que contenga puntos de datos y
las etiquetas correspondientes. Por ejemplo, si queremos verificar si la imagen
es de un automóvil o no. Para verificar esto, crearemos un conjunto de datos
de entrenamiento que tenga las dos clases relacionadas con "auto" y "no
auto". Luego necesitamos entrenar el modelo usando las muestras de
entrenamiento. Los modelos de clasificación se utilizan principalmente en
reconocimiento facial, identificación de spam, etc.

Pasos para construir un clasificador en Python

Para construir un clasificador en Python, vamos a utilizar Python 3 y Scikit-
learn, que es una herramienta para el aprendizaje automático. Siga estos
pasos para construir un clasificador en Python:

Paso 1 - Importar Scikit-learn

Este sería el primer paso para construir un clasificador en Python. En este

paso, instalaremos un paquete de Python llamado Scikit-learn, que es uno de
los mejores módulos de aprendizaje automático en Python. El siguiente
comando nos ayudará a importar el paquete:
Import Sklearn

Paso 2: importar el conjunto de datos de Scikit-learn

En este paso, podemos comenzar a trabajar con el conjunto de datos para

nuestro modelo de aprendizaje automático. Aquí, vamos a utilizar la base de
datos de diagnóstico de cáncer de seno de Wisconsin. El conjunto de datos
incluye información variada sobre tumores de cáncer de seno, así como
etiquetas de clasificación de malignas o benignas . El conjunto de datos tiene
569 instancias, o datos, sobre 569 tumores e incluye información sobre 30
atributos o características, como el radio del tumor, la textura, la suavidad y el
área. Con la ayuda del siguiente comando, podemos importar el conjunto de
datos de cáncer de seno de Scikit-learn:
from sklearn.datasets import load_breast_cancer
Ahora, el siguiente comando cargará el conjunto de datos.
data = load_breast_cancer()
A continuación hay una lista de claves importantes del diccionario:

 Nombres de etiquetas de clasificación (target_names)

 Las etiquetas reales (objetivo)
 Los nombres de atributo / característica (feature_names)
 El atributo (datos)
Ahora, con la ayuda del siguiente comando, podemos crear nuevas variables
para cada conjunto importante de información y asignar los datos. En otras
palabras, podemos organizar los datos con los siguientes comandos:
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']
Ahora, para que quede más claro, podemos imprimir las etiquetas de clase, la
etiqueta de la primera instancia de datos, nuestros nombres de funciones y el
valor de la función con la ayuda de los siguientes comandos:
print(label_names)
El comando anterior imprimirá los nombres de clase que son malignos y
benignos, respectivamente. Se muestra como la salida a continuación:
['malignant' 'benign']
Ahora, el comando a continuación mostrará que están asignados a valores
binarios 0 y 1. Aquí 0 representa cáncer maligno y 1 representa cáncer
benigno. Recibirá el siguiente resultado:
print(labels[0])
0
Los dos comandos que se proporcionan a continuación generarán los
nombres y los valores de las características.
print(feature_names[0])
mean radius
print(features[0])
[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03
1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
4.60100000e-01 1.18900000e-01]
A partir del resultado anterior, podemos ver que la primera instancia de datos
es un tumor maligno cuyo radio es 1.7990000e + 01.

Paso 3: organizar los datos en conjuntos

En este paso, dividiremos nuestros datos en dos partes, a saber, un conjunto

de entrenamiento y un conjunto de prueba. Dividir los datos en estos conjuntos
es muy importante porque tenemos que probar nuestro modelo en los datos
invisibles. Para dividir los datos en conjuntos, sklearn tiene una función
llamada train_test_split () . Con la ayuda de los siguientes comandos,
podemos dividir los datos en estos conjuntos:
from sklearn.model_selection import train_test_split
El comando anterior importará la función train_test_split de sklearn y el
comando siguiente dividirá los datos en datos de entrenamiento y prueba. En
el ejemplo que se muestra a continuación, estamos utilizando el 40% de los
datos para las pruebas y los datos restantes se utilizarían para entrenar el
modelo.
train, test, train_labels, test_labels =
train_test_split(features,labels,test_size = 0.40,
random_state = 42)

Paso 4 - Construyendo el modelo

En este paso, construiremos nuestro modelo. Vamos a utilizar el algoritmo

Naïve Bayes para construir el modelo. Los siguientes comandos se pueden
usar para construir el modelo:
from sklearn.naive_bayes import GaussianNB
El comando anterior importará el módulo GaussianNB. Ahora, el siguiente
comando lo ayudará a inicializar el modelo.
gnb = GaussianNB()
Entrenaremos el modelo ajustándolo a los datos usando gnb.fit ().
model = gnb.fit(train, train_labels)

Paso 5: evaluación del modelo y su precisión

En este paso, vamos a evaluar el modelo haciendo predicciones en nuestros

datos de prueba. Entonces descubriremos su precisión también. Para hacer
predicciones, usaremos la función predic (). El siguiente comando te ayudará a
hacer esto:
preds = gnb.predict(test)
print(preds)

[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1
0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0
0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1 1 1 1 1 0 1 1 0 0 0 0
 0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0 1 1 0 0 0
1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0
1 0 0 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0
1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0
1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 1 0 1]
La serie anterior de 0s y 1s son los valores predichos para las clases de
tumores: malignos y benignos.
Ahora, al comparar las dos matrices, a saber test_labels y preds , podemos
descubrir la precisión de nuestro modelo. Vamos a utilizar la
función precision_score () para determinar la precisión. Considere el
siguiente comando para esto:
from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965
El resultado muestra que el clasificador NaïveBayes tiene una precisión del
95,17%.
De esta manera, con la ayuda de los pasos anteriores, podemos construir
nuestro clasificador en Python.

Clasificador de construcción en Python

En esta sección, aprenderemos cómo construir un clasificador en Python.

Clasificador Naïve Bayes

Naïve Bayes es una técnica de clasificación utilizada para construir

clasificador utilizando el teorema de Bayes. La suposición es que los
predictores son independientes. En palabras simples, se supone que la
presencia de una característica particular en una clase no está relacionada
con la presencia de ninguna otra característica. Para construir el clasificador
Naïve Bayes necesitamos usar la biblioteca de Python llamada scikit
learn. Hay tres tipos de modelos Naïve Bayes llamados Gaussian,
Multinomial y Bernoulli en el paquete de aprendizaje scikit.
Para construir un modelo clasificador de aprendizaje automático Naïve Bayes,
necesitamos lo siguiente y menos

Conjunto de datos

Vamos a utilizar el conjunto de datos llamado Base de datos de diagnóstico de

cáncer de seno de Wisconsin. El conjunto de datos incluye información
variada sobre tumores de cáncer de seno, así como etiquetas de clasificación
de malignas o benignas . El conjunto de datos tiene 569 instancias, o datos,
sobre 569 tumores e incluye información sobre 30 atributos o características,
como el radio del tumor, la textura, la suavidad y el área. Podemos importar
este conjunto de datos desde el paquete sklearn.

Modelo Naïve Bayes

Para construir el clasificador Naïve Bayes, necesitamos un modelo Naïve
Bayes. Como se dijo anteriormente, hay tres tipos de modelos Naïve Bayes
llamados Gaussian, Multinomial y Bernoulli en el paquete de aprendizaje
scikit. Aquí, en el siguiente ejemplo, vamos a utilizar el modelo gaussiano
Naïve Bayes.
Al usar lo anterior, vamos a construir un modelo de aprendizaje automático
Naïve Bayes para usar la información del tumor para predecir si un tumor es
maligno o benigno.
Para empezar, necesitamos instalar el módulo sklearn. Se puede hacer con la
ayuda del siguiente comando:
Import Sklearn
Ahora, necesitamos importar el conjunto de datos llamado Breast Cancer
Wisconsin Diagnostic Database.
from sklearn.datasets import load_breast_cancer

Ahora, el siguiente comando cargará el conjunto de datos.

data = load_breast_cancer()
Los datos se pueden organizar de la siguiente manera:
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']

Ahora, para que quede más claro, podemos imprimir las etiquetas de clase, la
etiqueta de la primera instancia de datos, nuestros nombres de características
y el valor de la característica con la ayuda de los siguientes comandos:
print(label_names)
El comando anterior imprimirá los nombres de clase que son malignos y
benignos, respectivamente. Se muestra como la salida a continuación:
['malignant' 'benign']
Ahora, el comando que se muestra a continuación mostrará que están
asignados a valores binarios 0 y 1. Aquí 0 representa cáncer maligno y 1
representa cáncer benigno. Se muestra como la salida a continuación:
print(labels[0])
0
Los siguientes dos comandos generarán los nombres y los valores de las
características.
print(feature_names[0])
mean radius
print(features[0])

[ 1.79900000e+01 1.03800000e+01 1.22800000e+02 1.00100000e+03

1.18400000e-01 2.77600000e-01 3.00100000e-01 1.47100000e-01
2.41900000e-01 7.87100000e-02 1.09500000e+00 9.05300000e-01
 8.58900000e+00 1.53400000e+02 6.39900000e-03 4.90400000e-02
5.37300000e-02 1.58700000e-02 3.00300000e-02 6.19300000e-03
2.53800000e+01 1.73300000e+01 1.84600000e+02 2.01900000e+03
1.62200000e-01 6.65600000e-01 7.11900000e-01 2.65400000e-01
4.60100000e-01 1.18900000e-01]
A partir del resultado anterior, podemos ver que la primera instancia de datos
es un tumor maligno cuyo radio principal es 1.7990000e + 01.
Para probar nuestro modelo en datos no vistos, necesitamos dividir nuestros
datos en datos de capacitación y prueba. Se puede hacer con la ayuda del
siguiente código:
from sklearn.model_selection import train_test_split
El comando anterior importará la función train_test_split de sklearn y el
comando siguiente dividirá los datos en datos de entrenamiento y prueba. En
el siguiente ejemplo, estamos utilizando el 40% de los datos para las pruebas
y los datos de recordatorio se utilizarían para entrenar el modelo.
train, test, train_labels, test_labels =
train_test_split(features,labels,test_size = 0.40,
random_state = 42)

Ahora, estamos construyendo el modelo con los siguientes comandos:

from sklearn.naive_bayes import GaussianNB
El comando anterior importará el módulo GaussianNB . Ahora, con el
comando dado a continuación, necesitamos inicializar el modelo.
gnb = GaussianNB()
Entrenaremos el modelo ajustándolo a los datos usando gnb.fit () .
model = gnb.fit(train, train_labels)
Ahora, evalúe el modelo haciendo predicciones sobre los datos de prueba y se
puede hacer de la siguiente manera:
preds = gnb.predict(test)
print(preds)

[1 0 0 1 1 0 0 0 1 1 1 0 1 0 1 0 1 1 1 0 1 1 0 1 1 1 1 1 1
0 1 1 1 1 1 1 0 1 0 1 1 0 1 1 1 1 1 1 1 1 0 0 1 1 1 1 1 0
0 1 1 0 0 1 1 1 0 0 1 1 0 0 1 0 1 1 1 1 1 1 0 1 1 0 0 0 0
0 1 1 1 1 1 1 1 1 0 0 1 0 0 1 0 0 1 1 1 0 1 1 0 1 1 0 0 0
1 1 1 0 0 1 1 0 1 0 0 1 1 0 0 0 1 1 1 0 1 1 0 0 1 0 1 1 0
1 0 0 1 1 1 1 1 1 1 0 0 1 1 1 1 1 1 1 1 1 1 1 1 0 1 1 1 0
1 1 0 1 1 1 1 1 1 0 0 0 1 1 0 1 0 1 1 1 1 0 1 1 0 1 1 1 0
1 0 0 1 1 1 1 1 1 1 1 0 1 1 1 1 1 0 1 0 0 1 1 0 1]

La serie anterior de 0s y 1s son los valores predichos para las clases de

tumores, es decir, malignos y benignos.
Ahora, al comparar las dos matrices, a saber test_labels y preds , podemos
descubrir la precisión de nuestro modelo. Vamos a utilizar la
función precision_score () para determinar la precisión. Considere el
siguiente comando:
from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965
El resultado muestra que el clasificador NaïveBayes tiene una precisión del
95,17%.
Ese fue el clasificador de aprendizaje automático basado en el modelo
gaussiano Naïve Bayse.

Máquinas de vectores de soporte (SVM)

Básicamente, la máquina de vectores de soporte (SVM) es un algoritmo de

aprendizaje automático supervisado que se puede utilizar tanto para la
regresión como para la clasificación. El concepto principal de SVM es trazar
cada elemento de datos como un punto en el espacio n-dimensional con el
valor de cada entidad como el valor de una coordenada particular. Aquí n
serían las características que tendríamos. A continuación se presenta una
representación gráfica simple para comprender el concepto de SVM:

En el diagrama anterior, tenemos dos características. Por lo tanto, primero

debemos trazar estas dos variables en un espacio bidimensional donde cada
punto tiene dos coordenadas, llamadas vectores de soporte. La línea divide
los datos en dos grupos clasificados diferentes. Esta línea sería el clasificador.
Aquí, vamos a construir un clasificador SVM utilizando scikit-learn y el
conjunto de datos de iris. La biblioteca Scikitlearn tiene
el módulo sklearn.svm y proporciona sklearn.svm.svc para la clasificación. A
continuación se muestra el clasificador SVM para predecir la clase de la planta
de iris basada en 4 características.

Conjunto de datos

Utilizaremos el conjunto de datos de iris que contiene 3 clases de 50

instancias cada una, donde cada clase se refiere a un tipo de planta de
iris. Cada instancia tiene las cuatro características, a saber, longitud del
sépalo, ancho del sépalo, longitud del pétalo y ancho del pétalo. A
continuación se muestra el clasificador SVM para predecir la clase de la planta
de iris basada en 4 características.

Núcleo

Es una técnica utilizada por SVM. Básicamente, estas son las funciones que
toman el espacio de entrada de baja dimensión y lo transforman en un espacio
de mayor dimensión. Convierte un problema no separable en un problema
separable. La función del núcleo puede ser cualquiera entre lineal, polinomial,
rbf y sigmoide. En este ejemplo, utilizaremos el núcleo lineal.
Vamos a importar ahora los siguientes paquetes:
import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt

Ahora, cargue los datos de entrada -

iris = datasets.load_iris()
Estamos tomando las dos primeras características:
X = iris.data[:, :2]
y = iris.target

Trazaremos los límites de la máquina de vectores de soporte con datos

originales. Estamos creando una malla para trazar.
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
h = (x_max / x_min)/100
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
X_plot = np.c_[xx.ravel(), yy.ravel()]
Necesitamos dar el valor del parámetro de regularización.
C = 1.0

Necesitamos crear el objeto clasificador SVM.

Svc_classifier = svm_classifier.SVC(kernel='linear',
C=C, decision_function_shape = 'ovr').fit(X, y)
Z = svc_classifier.predict(X_plot)
Z = Z.reshape(xx.shape)
plt.figure(figsize = (15, 5))
plt.subplot(121)
plt.contourf(xx, yy, Z, cmap = plt.cm.tab10, alpha = 0.3)
plt.scatter(X[:, 0], X[:, 1], c = y, cmap = plt.cm.Set1)
plt.xlabel('Sepal length')
plt.ylabel('Sepal width')
plt.xlim(xx.min(), xx.max())
plt.title('SVC with linear kernel')
Regresión logística
Básicamente, el modelo de regresión logística es uno de los miembros de la
familia de algoritmos de clasificación supervisada. La regresión logística mide
la relación entre variables dependientes y variables independientes mediante
la estimación de las probabilidades utilizando una función logística.
Aquí, si hablamos de variables dependientes e independientes, entonces la
variable dependiente es la variable de clase objetivo que vamos a predecir y,
por otro lado, las variables independientes son las características que vamos a
usar para predecir la clase objetivo.
En la regresión logística, estimar las probabilidades significa predecir la
probabilidad de ocurrencia del evento. Por ejemplo, al dueño de la tienda le
gustaría predecir que el cliente que ingresó a la tienda comprará la play station
(por ejemplo) o no. Habría muchas características del cliente: género, edad,
etc. que el encargado de la tienda observaría para predecir la probabilidad de
ocurrencia, es decir, comprar una estación de juegos o no. La función logística
es la curva sigmoidea que se utiliza para construir la función con varios
parámetros.

Prerrequisitos

Antes de construir el clasificador usando regresión logística, necesitamos

instalar el paquete Tkinter en nuestro sistema. Se puede instalar
desde https://docs.python.org/2/library/tkinter.html .
Ahora, con la ayuda del código que se proporciona a continuación, podemos
crear un clasificador mediante regresión logística:
Primero, importaremos algunos paquetes:
import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt
Ahora, necesitamos definir los datos de muestra que se pueden hacer de la
siguiente manera:
X = np.array([[2, 4.8], [2.9, 4.7], [2.5, 5], [3.2, 5.5], [6,
5], [7.6, 4],
[3.2, 0.9], [2.9, 1.9],[2.4, 3.5], [0.5, 3.4],
[1, 4], [0.9, 5.9]])
y = np.array([0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3])

A continuación, necesitamos crear el clasificador de regresión logística, que se

puede hacer de la siguiente manera:
Classifier_LR = linear_model.LogisticRegression(solver =
'liblinear', C = 75)
Por último, pero no menos importante, necesitamos entrenar este clasificador:
Classifier_LR.fit(X, y)
Ahora, ¿cómo podemos visualizar la salida? Se puede hacer creando una
función llamada Logistic_visualize () -
Def Logistic_visualize(Classifier_LR, X, y):
min_x, max_x = X[:, 0].min() - 1.0, X[:, 0].max() + 1.0
min_y, max_y = X[:, 1].min() - 1.0, X[:, 1].max() + 1.0
En la línea anterior, definimos los valores mínimos y máximos X e Y que se
utilizarán en la malla de malla. Además, definiremos el tamaño del paso para
trazar la cuadrícula de malla.
mesh_step_size = 0.02
Definamos la cuadrícula de malla de los valores X e Y de la siguiente manera:
x_vals, y_vals = np.meshgrid(np.arange(min_x, max_x,
mesh_step_size),
np.arange(min_y, max_y, mesh_step_size))
Con la ayuda del siguiente código, podemos ejecutar el clasificador en la
cuadrícula de malla:
output = classifier.predict(np.c_[x_vals.ravel(),
y_vals.ravel()])
output = output.reshape(x_vals.shape)
plt.figure()
plt.pcolormesh(x_vals, y_vals, output, cmap = plt.cm.gray)

plt.scatter(X[:, 0], X[:, 1], c = y, s = 75, edgecolors =

'black',
linewidth=1, cmap = plt.cm.Paired)
La siguiente línea de código especificará los límites de la trama
plt.xlim(x_vals.min(), x_vals.max())
plt.ylim(y_vals.min(), y_vals.max())
plt.xticks((np.arange(int(X[:, 0].min() - 1), int(X[:,
0].max() + 1), 1.0)))
plt.yticks((np.arange(int(X[:, 1].min() - 1), int(X[:,
1].max() + 1), 1.0)))
plt.show()
Ahora, después de ejecutar el código, obtendremos el siguiente resultado,
clasificador de regresión logística:

Clasificador de árbol de decisión

Un árbol de decisión es básicamente un diagrama de flujo de árbol binario
donde cada nodo divide un grupo de observaciones de acuerdo con alguna
variable de característica.
Aquí, estamos construyendo un clasificador de árbol de decisión para predecir
hombres o mujeres. Tomaremos un conjunto de datos muy pequeño con 19
muestras. Estas muestras constarían de dos características: "altura" y
"longitud del cabello".

Requisito previo

Para construir el siguiente clasificador, necesitamos

instalar pydotplus y graphviz . Básicamente, graphviz es una herramienta
para dibujar gráficos usando archivos de puntos y pydotplus es un módulo
para el lenguaje Dot de Graphviz. Se puede instalar con el administrador de
paquetes o pip.
Ahora, podemos construir el clasificador del árbol de decisión con la ayuda del
siguiente código de Python:
Para empezar, importemos algunas bibliotecas importantes de la siguiente
manera:
import pydotplus
from sklearn import tree
from sklearn.datasets import load_iris
from sklearn.metrics import classification_report
from sklearn import cross_validation
import collections
Ahora, necesitamos proporcionar el conjunto de datos de la siguiente manera:
X =
[[165,19],[175,32],[136,35],[174,65],[141,28],[176,15],[131,3
2],
[166,6],[128,32],[179,10],[136,34],[186,2],[126,25],[176,28],
[112,38],
[169,9],[171,36],[116,25],[196,25]]

Y =
['Man','Woman','Woman','Man','Woman','Man','Woman','Man','Wom
an',
'Man','Woman','Man','Woman','Woman','Woman','Man','Woman','Wo
man','Man']
data_feature_names = ['height','length of hair']

X_train, X_test, Y_train, Y_test =

cross_validation.train_test_split
(X, Y, test_size=0.40, random_state=5)
Después de proporcionar el conjunto de datos, debemos ajustar el modelo que
se puede hacer de la siguiente manera:
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,Y)

La predicción se puede hacer con la ayuda del siguiente código Python:

prediction = clf.predict([[133,37]])
print(prediction)
Podemos visualizar el árbol de decisión con la ayuda del siguiente código de
Python:
dot_data = tree.export_graphviz(clf,feature_names =
data_feature_names,
out_file = None,filled = True,rounded = True)
graph = pydotplus.graph_from_dot_data(dot_data)
colors = ('orange', 'yellow')
edges = collections.defaultdict(list)

for edge in graph.get_edge_list():

edges[edge.get_source()].append(int(edge.get_destination()))

for edge in edges: edges[edge].sort()

for i in range(2):dest =
graph.get_node(str(edges[edge][i]))[0]
dest.set_fillcolor(colors[i])
graph.write_png('Decisiontree16.png')
Dará la predicción para el código anterior como ['Mujer'] y creará el siguiente
árbol de decisión:

Podemos cambiar los valores de las características en la predicción para

probarlo.

Clasificador de bosque aleatorio

Como sabemos, los métodos de conjunto son los métodos que combinan
modelos de aprendizaje automático en un modelo de aprendizaje automático
más potente. Random Forest, una colección de árboles de decisión, es uno de
ellos. Es mejor que el árbol de decisión único porque al retener los poderes
predictivos puede reducir el sobreajuste promediando los resultados. Aquí,
vamos a implementar el modelo de bosque aleatorio en scikit learn cancer
dataset.
Importar los paquetes necesarios -
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()
import matplotlib.pyplot as plt
import numpy as np
Ahora, necesitamos proporcionar el conjunto de datos que se puede hacer de
la siguiente manera y menos
cancer = load_breast_cancer()
X_train, X_test, y_train,
y_test = train_test_split(cancer.data, cancer.target,
random_state = 0)

Después de proporcionar el conjunto de datos, debemos ajustar el modelo que

se puede hacer de la siguiente manera:
forest = RandomForestClassifier(n_estimators = 50,
random_state = 0)
forest.fit(X_train,y_train)
Ahora, obtenga la precisión en el entrenamiento y en el subconjunto de
pruebas: si aumentamos el número de estimadores, la precisión del
subconjunto de pruebas también aumentaría.
print('Accuracy on the training
subset:(:.3f)',format(forest.score(X_train,y_train)))
print('Accuracy on the training
subset:(:.3f)',format(forest.score(X_test,y_test)))

Salida

Accuracy on the training subset:(:.3f) 1.0

Accuracy on the training subset:(:.3f) 0.965034965034965
Ahora, al igual que el árbol de decisión, el bosque aleatorio tiene
el módulo feature_importance que proporcionará una mejor vista del peso de
la característica que el árbol de decisión. Se puede trazar y visualizar de la
siguiente manera:
n_features = cancer.data.shape[1]
plt.barh(range(n_features),forest.feature_importances_,
align='center')
plt.yticks(np.arange(n_features),cancer.feature_names)
plt.xlabel('Feature Importance')
plt.ylabel('Feature')
plt.show()
Rendimiento de un clasificador
Después de implementar un algoritmo de aprendizaje automático,
necesitamos descubrir qué tan efectivo es el modelo. Los criterios para medir
la efectividad pueden basarse en conjuntos de datos y métricas. Para evaluar
diferentes algoritmos de aprendizaje automático, podemos utilizar diferentes
métricas de rendimiento. Por ejemplo, supongamos que si se usa un
clasificador para distinguir entre imágenes de diferentes objetos, podemos
usar las métricas de rendimiento de clasificación como la precisión promedio,
AUC, etc. En uno u otro sentido, la métrica que elegimos para evaluar nuestro
modelo de aprendizaje automático es muy importante porque la elección de
las métricas influye en cómo se mide y compara el rendimiento de un
algoritmo de aprendizaje automático. Las siguientes son algunas de las
métricas:

Matriz de confusión

Básicamente se usa para problemas de clasificación donde la salida puede ser

de dos o más tipos de clases. Es la forma más fácil de medir el rendimiento de
un clasificador. Una matriz de confusión es básicamente una tabla con dos
dimensiones, a saber, "Actual" y "Predicho". Ambas dimensiones tienen
"Positivos verdaderos (TP)", "Negativos verdaderos (TN)", "Positivos falsos
(FP)", "Negativos falsos (FN)".
En la matriz de confusión anterior, 1 es para clase positiva y 0 es para clase
negativa.
Los siguientes son los términos asociados con la matriz de confusión:
 Positivos verdaderos: los TP son los casos en que la clase real de punto de
datos era 1 y la predicción también es 1.
 Verdaderos negativos: los TN son los casos en que la clase real del punto de
datos era 0 y la predicción también es 0.
 Positivos falsos: los FP son los casos en que la clase real de punto de datos era
0 y la predicción también es 1.
 Falsos negativos: los FN son los casos en que la clase real del punto de datos
era 1 y la predicción también es 0.

Exactitud

La matriz de confusión en sí misma no es una medida de rendimiento como

tal, pero casi todas las matrices de rendimiento se basan en la matriz de
confusión. Uno de ellos es la precisión. En problemas de clasificación, se
puede definir como el número de predicciones correctas realizadas por el
modelo sobre todo tipo de predicciones realizadas. La fórmula para calcular la
precisión es la siguiente:
$$ Precisión = \ frac {TP + TN} {TP + FP + FN + TN} $$

Precisión

Se utiliza principalmente en la recuperación de documentos. Puede definirse

como cuántos de los documentos devueltos son correctos. La siguiente es la
fórmula para calcular la precisión:
$$ Precisión = \ frac {TP} {TP + FP} $$

Retiro o sensibilidad

Se puede definir como cuántos de los positivos devuelve el modelo. La

siguiente es la fórmula para calcular la recuperación / sensibilidad del modelo:
$$ Recuperar = \ frac {TP} {TP + FN} $$

Especificidad

Se puede definir como cuántos de los negativos devuelve el modelo. Es

exactamente lo contrario de recordar. La siguiente es la fórmula para calcular
la especificidad del modelo:
$$ Especificidad = \ frac {TN} {TN + FP} $$

Problema de desequilibrio de clase

El desequilibrio de clase es el escenario en el que el número de observaciones
que pertenecen a una clase es significativamente menor que las que
pertenecen a las otras clases. Por ejemplo, este problema es prominente en el
escenario donde necesitamos identificar las enfermedades raras, las
transacciones fraudulentas en el banco, etc.

Ejemplo de clases desequilibradas

Consideremos un ejemplo de conjunto de datos de detección de fraude para

comprender el concepto de clase desequilibrada:
Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

Solución

El equilibrio de las clases actúa como una solución para las clases
desequilibradas. El objetivo principal de equilibrar las clases es aumentar la
frecuencia de la clase minoritaria o disminuir la frecuencia de la clase
mayoritaria. Los siguientes son los enfoques para resolver el problema de las
clases de desequilibrios:

Re-Muestreo

El nuevo muestreo es una serie de métodos utilizados para reconstruir los

conjuntos de datos de muestra, tanto conjuntos de entrenamiento como
conjuntos de prueba. El nuevo muestreo se realiza para mejorar la precisión
del modelo. Las siguientes son algunas técnicas de muestreo:
 Submuestreo aleatorio : esta técnica tiene como objetivo equilibrar la distribución
de clases al eliminar al azar ejemplos de clases mayoritarias. Esto se hace hasta
que las instancias de clase mayoritaria y minoritaria se equilibren.

Total observations = 5000

Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

En este caso, estamos tomando muestras del 10% sin reemplazo de

instancias sin fraude y luego las combinamos con las instancias de fraude:
Observaciones no fraudulentas después de un muestreo aleatorio = 10% de
4950 = 495
Observaciones totales después de combinarlas con observaciones
fraudulentas = 50 + 495 = 545
Por lo tanto, ahora, la tasa de eventos para el nuevo conjunto de datos
después del muestreo = 9%
La principal ventaja de esta técnica es que puede reducir el tiempo de
ejecución y mejorar el almacenamiento. Pero, por otro lado, puede descartar
información útil mientras reduce la cantidad de muestras de datos de
entrenamiento.
 Sobremuestreo aleatorio : esta técnica tiene como objetivo equilibrar la
distribución de la clase al aumentar el número de instancias en la clase minoritaria
al replicarlas.

Total observations = 5000

Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%

En caso de que estemos replicando 50 observaciones fraudulentas 30 veces,

las observaciones fraudulentas después de replicar las observaciones de
clase minoritaria serían 1500. Y luego las observaciones totales en los nuevos
datos después del sobremuestreo serían 4950 + 1500 = 6450. De ahí la tasa
de eventos para el nuevo conjunto de datos sería 1500/6450 = 23%.
La principal ventaja de este método es que no habría pérdida de información
útil. Pero, por otro lado, tiene mayores posibilidades de sobreajuste porque
replica los eventos de clase minoritaria.

Técnicas de conjunto
Básicamente, esta metodología se utiliza para modificar los algoritmos de
clasificación existentes para que sean apropiados para conjuntos de datos
desequilibrados. En este enfoque, construimos varios clasificadores de dos
etapas a partir de los datos originales y luego agregamos sus predicciones. El
clasificador de bosque aleatorio es un ejemplo de clasificador basado en
conjuntos.

AI con Python - Aprendizaje supervisado:

regresión
La regresión es una de las herramientas estadísticas y de aprendizaje
automático más importantes. No nos equivocaríamos al decir que el viaje del
aprendizaje automático comienza con la regresión. Puede definirse como la
técnica paramétrica que nos permite tomar decisiones basadas en datos o, en
otras palabras, nos permite hacer predicciones basadas en datos aprendiendo
la relación entre las variables de entrada y salida. Aquí, las variables de salida
que dependen de las variables de entrada son números reales con valores
continuos. En la regresión, la relación entre las variables de entrada y salida
es importante y nos ayuda a comprender cómo cambia el valor de la variable
de salida con el cambio de la variable de entrada. La regresión se usa con
frecuencia para la predicción de precios, economía, variaciones, etc.

Regresores de construcción en Python

En esta sección, aprenderemos cómo construir un regresor simple y
multivariable.

Regresor lineal / Regresor de variable única

Permítanos importantes algunos paquetes requeridos -

import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt

Ahora, necesitamos proporcionar los datos de entrada y hemos guardado

nuestros datos en el archivo llamado linear.txt.
input = 'D:/ProgramData/linear.txt'
Necesitamos cargar estos datos usando la función np.loadtxt .
input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]
El siguiente paso sería entrenar al modelo. Déjenos dar muestras de
entrenamiento y prueba.
training_samples = int(0.6 * len(X))
testing_samples = len(X) - num_training

X_train, y_train = X[:training_samples], y[:training_samples]

X_test, y_test = X[training_samples:], y[training_samples:]

Ahora, necesitamos crear un objeto regresor lineal.

reg_linear = linear_model.LinearRegression()
Entrena el objeto con las muestras de entrenamiento.
reg_linear.fit(X_train, y_train)
Necesitamos hacer la predicción con los datos de prueba.
y_test_pred = reg_linear.predict(X_test)
Ahora grafica y visualiza los datos.
plt.scatter(X_test, y_test, color = 'red')
plt.plot(X_test, y_test_pred, color = 'black', linewidth = 2)
plt.xticks(())
plt.yticks(())
plt.show()

Salida

Ahora, podemos calcular el rendimiento de nuestra regresión lineal de la

siguiente manera:
print("Performance of Linear regressor:")
print("Mean absolute error =",
round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error =",
round(sm.mean_squared_error(y_test, y_test_pred), 2))
print("Median absolute error =",
round(sm.median_absolute_error(y_test, y_test_pred), 2))
print("Explain variance score =",
round(sm.explained_variance_score(y_test, y_test_pred),
2))
print("R2 score =", round(sm.r2_score(y_test, y_test_pred),
2))

Salida

Rendimiento del regresor lineal -

Mean absolute error = 1.78
Mean squared error = 3.89
Median absolute error = 2.01
Explain variance score = -0.09
R2 score = -0.09
En el código anterior, hemos utilizado estos pequeños datos. Si desea un
conjunto de datos grande, puede usar sklearn.dataset para importar conjuntos
de datos más grandes.
2,4.82.9,4.72.5,53.2,5.56,57.6,43.2,0.92.9,1.92.4,
3.50.5,3.41,40.9,5.91.2,2.583.2,5.65.1,1.54.5,
1.22.3,6.32.1,2.8

Regresor multivariable

Primero, importemos algunos paquetes requeridos:

import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures

Ahora, necesitamos proporcionar los datos de entrada y hemos guardado

nuestros datos en el archivo llamado linear.txt.
input = 'D:/ProgramData/Mul_linear.txt'
Cargaremos estos datos utilizando la función np.loadtxt .
input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]
El siguiente paso sería entrenar al modelo; Le daremos muestras de
entrenamiento y prueba.
training_samples = int(0.6 * len(X))
testing_samples = len(X) - num_training

X_train, y_train = X[:training_samples], y[:training_samples]

X_test, y_test = X[training_samples:], y[training_samples:]

Ahora, necesitamos crear un objeto regresor lineal.
reg_linear_mul = linear_model.LinearRegression()
Entrena el objeto con las muestras de entrenamiento.
reg_linear_mul.fit(X_train, y_train)
Ahora, por fin necesitamos hacer la predicción con los datos de prueba.
y_test_pred = reg_linear_mul.predict(X_test)

print("Performance of Linear regressor:")

print("Mean absolute error =",
round(sm.mean_absolute_error(y_test, y_test_pred), 2))
print("Mean squared error =",
round(sm.mean_squared_error(y_test, y_test_pred), 2))
print("Median absolute error =",
round(sm.median_absolute_error(y_test, y_test_pred), 2))
print("Explain variance score =",
round(sm.explained_variance_score(y_test, y_test_pred), 2))
print("R2 score =", round(sm.r2_score(y_test, y_test_pred),
2))

Salida

Rendimiento del regresor lineal -

Mean absolute error = 0.6
Mean squared error = 0.65
Median absolute error = 0.41
Explain variance score = 0.34
R2 score = 0.33
Ahora, crearemos un polinomio de grado 10 y entrenaremos al
regresor. Proporcionaremos el punto de datos de muestra.
polynomial = PolynomialFeatures(degree = 10)
X_train_transformed = polynomial.fit_transform(X_train)
datapoint = [[2.23, 1.35, 1.12]]
poly_datapoint = polynomial.fit_transform(datapoint)

poly_linear_model = linear_model.LinearRegression()
poly_linear_model.fit(X_train_transformed, y_train)
print("\nLinear regression:\n",
reg_linear_mul.predict(datapoint))
print("\nPolynomial regression:\n",
poly_linear_model.predict(poly_datapoint))

Salida

Regresión lineal -
[2.40170462]
Regresión polinómica -
[1.8697225]
En el código anterior, hemos utilizado estos pequeños datos. Si desea un gran
conjunto de datos, puede usar sklearn.dataset para importar un conjunto de
datos más grande.
2,4.8,1.2,3.22.9,4.7,1.5,3.62.5,5,2.8,23.2,5.5,3.5,2.16,5,
2,3.27.6,4,1.2,3.23.2,0.9,2.3,1.42.9,1.9,2.3,1.22.4,3.5,
2.8,3.60.5,3.4,1.8,2.91,4,3,2.50.9,5.9,5.6,0.81.2,2.58,
3.45,1.233.2,5.6,2,3.25.1,1.5,1.2,1.34.5,1.2,4.1,2.32.3,
6.3,2.5,3.22.1,2.8,1.2,3.6

AI con Python - Programación lógica

En este capítulo, enfocaremos la programación lógica y cómo ayuda en la
Inteligencia Artificial.
Ya sabemos que la lógica es el estudio de los principios del razonamiento
correcto o, en palabras simples, es el estudio de lo que viene después de
qué. Por ejemplo, si dos afirmaciones son verdaderas, podemos inferir
cualquier tercera afirmación a partir de ella.

Concepto

La programación lógica es la combinación de dos palabras, lógica y

programación. La programación lógica es un paradigma de programación en el
que los problemas se expresan como hechos y reglas mediante declaraciones
del programa pero dentro de un sistema de lógica formal. Al igual que otros
paradigmas de programación como orientado a objetos, funcional, declarativo
y de procedimiento, etc., también es una forma particular de abordar la
programación.

Cómo resolver problemas con la programación lógica

La programación lógica utiliza hechos y reglas para resolver el problema. Es
por eso que se llaman los bloques de construcción de la programación
lógica. Se debe especificar un objetivo para cada programa en programación
lógica. Para comprender cómo se puede resolver un problema en la
programación lógica, necesitamos saber acerca de los bloques de
construcción - Hechos y Reglas -

Hechos

En realidad, cada programa lógico necesita hechos con los que trabajar para
poder alcanzar el objetivo dado. Los hechos son básicamente declaraciones
verdaderas sobre el programa y los datos. Por ejemplo, Delhi es la capital de
la India.

Reglas

En realidad, las reglas son las restricciones que nos permiten sacar
conclusiones sobre el dominio del problema. Reglas básicamente escritas
como cláusulas lógicas para expresar varios hechos. Por ejemplo, si estamos
construyendo algún juego, entonces todas las reglas deben estar definidas.
Las reglas son muy importantes para resolver cualquier problema en la
programación lógica. Las reglas son básicamente una conclusión lógica que
puede expresar los hechos. La siguiente es la sintaxis de la regla:
A∶− B1, B2, ..., B n .
Aquí, A es la cabeza y B1, B2, ... Bn es el cuerpo.
Por ejemplo - ancestro (X, Y): - padre (X, Y).
ancestro (X, Z): - padre (X, Y), ancestro (Y, Z).
Esto se puede leer como, para cada X e Y, si X es el padre de Y e Y es un
ancestro de Z, X es el ancestro de Z. Por cada X e Y, X es el ancestro de Z, si
X es El padre de Y e Y es un antepasado de Z.

Instalar paquetes útiles

Para iniciar la programación lógica en Python, necesitamos instalar los
siguientes dos paquetes:

Kanren

Nos proporciona una manera de simplificar la forma en que creamos el código

para la lógica empresarial. Nos permite expresar la lógica en términos de
reglas y hechos. El siguiente comando te ayudará a instalar kanren:
pip install kanren

SymPy

SymPy es una biblioteca de Python para matemática simbólica. Su objetivo es

convertirse en un sistema de álgebra computacional (CAS) con todas las
funciones, manteniendo el código lo más simple posible para que sea
comprensible y fácilmente extensible. El siguiente comando lo ayudará a
instalar SymPy:
pip install sympy

Ejemplos de programación lógica

Los siguientes son algunos ejemplos que pueden resolverse mediante
programación lógica:

Coincidencia de expresiones matemáticas

En realidad, podemos encontrar los valores desconocidos usando la

programación lógica de una manera muy efectiva. El siguiente código de
Python lo ayudará a hacer coincidir una expresión matemática:
Considere importar los siguientes paquetes primero:
from kanren import run, var, fact
from kanren.assoccomm import eq_assoccomm as eq
from kanren.assoccomm import commutative, associative

Necesitamos definir las operaciones matemáticas que vamos a utilizar:

add = 'add'
mul = 'mul'
Tanto la suma como la multiplicación son procesos comunicativos. Por lo
tanto, debemos especificarlo y esto se puede hacer de la siguiente manera:
fact(commutative, mul)
fact(commutative, add)
fact(associative, mul)
fact(associative, add)
Es obligatorio definir variables; Esto se puede hacer de la siguiente manera:
a, b = var('a'), var('b')
Necesitamos hacer coincidir la expresión con el patrón original. Tenemos el
siguiente patrón original, que es básicamente (5 + a) * b -
Original_pattern = (mul, (add, 5, a), b)
Tenemos las siguientes dos expresiones para que coincidan con el patrón
original:
exp1 = (mul, 2, (add, 3, 1))
exp2 = (add,5,(mul,8,1))

La salida se puede imprimir con el siguiente comando:

print(run(0, (a,b), eq(original_pattern, exp1)))
print(run(0, (a,b), eq(original_pattern, exp2)))
Después de ejecutar este código, obtendremos el siguiente resultado:
((3,2))
()
La primera salida representa los valores para a y b . La primera expresión se
correspondía con el patrón original y devuelve los valores para un y b , pero la
segunda expresión no coincide con el patrón original por lo tanto, nada se ha
devuelto.

Comprobación de números primos

Con la ayuda de la programación lógica, podemos encontrar los números
primos de una lista de números y también podemos generar números
primos. El código de Python que figura a continuación encontrará el número
primo de una lista de números y también generará los primeros 10 números
primos.
Consideremos primero la importación de los siguientes paquetes:
from kanren import isvar, run, membero
from kanren.core import success, fail, goaleval, condeseq,
eq, var
from sympy.ntheory.generate import prime, isprime
import itertools as it
Ahora, definiremos una función llamada prime_check que verificará los
números primos basados en los números dados como datos.
def prime_check(x):
if isvar(x):
 return condeseq([(eq,x,p)] for p in map(prime,
it.count(1)))
else:
return success if isprime(x) else fail
Ahora, tenemos que declarar una variable que se utilizará:
x = var()
print((set(run(0,x,(membero,x,(12,14,15,19,20,21,22,23,29,30,
41,44,52,62,65,85)),
(prime_check,x)))))
print((run(10,x,prime_check(x))))

La salida del código anterior será la siguiente:

{19, 23, 29, 41}
(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)

Resolviendo rompecabezas
La programación lógica se puede utilizar para resolver muchos problemas
como 8 rompecabezas, rompecabezas de cebra, Sudoku, N-queen, etc. Aquí
estamos tomando un ejemplo de una variante del rompecabezas de Zebra que
es el siguiente:
There are five houses.
The English man lives in the red house.
The Swede has a dog.
The Dane drinks tea.
The green house is immediately to the left of the white
house.
They drink coffee in the green house.
The man who smokes Pall Mall has birds.
In the yellow house they smoke Dunhill.
In the middle house they drink milk.
The Norwegian lives in the first house.
The man who smokes Blend lives in the house next to the house
with cats.
In a house next to the house where they have a horse, they
smoke Dunhill.
The man who smokes Blue Master drinks beer.
The German smokes Prince.
The Norwegian lives next to the blue house.
They drink water in a house next to the house where they
smoke Blend.
Lo estamos resolviendo para la pregunta de quién posee zebra con la ayuda
de Python.
Importemos los paquetes necesarios:
from kanren import *
from kanren.core import lall
import time
Ahora, necesitamos definir dos funciones: left () y next () para verificar qué
casa queda o al lado de quién.
def left(q, p, list):
return membero((q,p), zip(list, list[1:]))
def next(q, p, list):
return conde([left(q, p, list)], [left(p, q, list)])

Ahora, declararemos una casa variable de la siguiente manera:

houses = var()
Necesitamos definir las reglas con la ayuda del paquete lall de la siguiente
manera.
Hay 5 casas -
rules_zebraproblem = lall(
(eq, (var(), var(), var(), var(), var()), houses),

(membero,('Englishman', var(), var(), var(), 'red'),

houses),
(membero,('Swede', var(), var(), 'dog', var()), houses),
(membero,('Dane', var(), 'tea', var(), var()), houses),
(left,(var(), var(), var(), var(), 'green'),
(var(), var(), var(), var(), 'white'), houses),
(membero,(var(), var(), 'coffee', var(), 'green'),
houses),
(membero,(var(), 'Pall Mall', var(), 'birds', var()),
houses),
(membero,(var(), 'Dunhill', var(), var(), 'yellow'),
houses),
(eq,(var(), var(), (var(), var(), 'milk', var(), var()),
var(), var()), houses),
(eq,(('Norwegian', var(), var(), var(), var()), var(),
var(), var(), var()), houses),
(next,(var(), 'Blend', var(), var(), var()),
(var(), var(), var(), 'cats', var()), houses),
(next,(var(), 'Dunhill', var(), var(), var()),
(var(), var(), var(), 'horse', var()), houses),
(membero,(var(), 'Blue Master', 'beer', var(), var()),
houses),
(membero,('German', 'Prince', var(), var(), var()),
houses),
(next,('Norwegian', var(), var(), var(), var()),
(var(), var(), var(), var(), 'blue'), houses),
(next,(var(), 'Blend', var(), var(), var()),
(var(), var(), 'water', var(), var()), houses),
(membero,(var(), var(), var(), 'zebra', var()), houses)
)
Ahora, ejecute el solucionador con las restricciones anteriores:
solutions = run(0, houses, rules_zebraproblem)
Con la ayuda del siguiente código, podemos extraer el resultado del
solucionador:
output_zebra = [house for house in solutions[0] if 'zebra' in
house][0][0]
El siguiente código ayudará a imprimir la solución:
print ('\n'+ output_zebra + 'owns zebra.')
El resultado del código anterior sería el siguiente:
German owns zebra.
AI con Python - Aprendizaje no supervisado:
agrupamiento
Los algoritmos de aprendizaje automático no supervisados no tienen ningún
supervisor que brinde ningún tipo de orientación. Es por eso que están
estrechamente alineados con lo que algunos llaman verdadera inteligencia
artificial.
En el aprendizaje no supervisado, no habría una respuesta correcta y ningún
maestro para la orientación. Los algoritmos necesitan descubrir el patrón
interesante en los datos para el aprendizaje.

¿Qué es la agrupación?
Básicamente, es un tipo de método de aprendizaje no supervisado y una
técnica común para el análisis de datos estadísticos utilizado en muchos
campos. La agrupación es principalmente una tarea de dividir el conjunto de
observaciones en subconjuntos, llamados grupos, de tal manera que las
observaciones en el mismo grupo son similares en un sentido y son diferentes
a las observaciones en otros grupos. En palabras simples, podemos decir que
el objetivo principal de la agrupación es agrupar los datos sobre la base de
similitud y disimilitud.
Por ejemplo, el siguiente diagrama muestra un tipo similar de datos en
diferentes grupos:
Algoritmos para agrupar los datos
Los siguientes son algunos algoritmos comunes para agrupar los datos:

Algoritmo K-medias

El algoritmo de agrupamiento K-means es uno de los algoritmos bien

conocidos para agrupar los datos. Debemos suponer que ya se conocen los
números de grupos. Esto también se llama agrupación plana. Es un algoritmo
de agrupamiento iterativo. Los pasos dados a continuación deben seguirse
para este algoritmo:
Paso 1 : necesitamos especificar el número deseado de K subgrupos.
Paso 2 : fije el número de clústeres y asigne aleatoriamente cada punto de
datos a un clúster. O, en otras palabras, debemos clasificar nuestros datos en
función del número de clústeres.
En este paso, se deben calcular los centroides del clúster.
Como se trata de un algoritmo iterativo, necesitamos actualizar las
ubicaciones de los centroides K con cada iteración hasta que encontremos los
óptimos globales o, en otras palabras, los centroides alcanzan sus ubicaciones
óptimas.
El siguiente código ayudará a implementar el algoritmo de agrupación de K-
means en Python. Vamos a usar el módulo Scikit-learn.
Importemos los paquetes necesarios:
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
La siguiente línea de código ayudará a generar el conjunto de datos
bidimensional, que contiene cuatro blobs,
utilizando make_blob del paquete sklearn.dataset .
from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4,

cluster_std = 0.40, random_state = 0)
Podemos visualizar el conjunto de datos usando el siguiente código:
plt.scatter(X[:, 0], X[:, 1], s = 50);
plt.show()

Aquí, estamos inicializando kmeans para que sea el algoritmo KMeans, con el
parámetro requerido de cuántos clústeres (n_clusters).
kmeans = KMeans(n_clusters = 4)
Necesitamos entrenar el modelo K-means con los datos de entrada.
kmeans.fit(X)
y_kmeans = kmeans.predict(X)
plt.scatter(X[:, 0], X[:, 1], c = y_kmeans, s = 50, cmap =
'viridis')

centers = kmeans.cluster_centers_

El código que se proporciona a continuación nos ayudará a trazar y visualizar

los hallazgos de la máquina en función de nuestros datos y el ajuste de
acuerdo con el número de grupos que se encuentran.
plt.scatter(centers[:, 0], centers[:, 1], c = 'black', s =
200, alpha = 0.5);
plt.show()
Algoritmo de cambio medio

Es otro algoritmo de agrupamiento popular y poderoso utilizado en el

aprendizaje no supervisado. No hace ninguna suposición, por lo tanto, es un
algoritmo no paramétrico. También se denomina agrupación jerárquica o
análisis de agrupación de desplazamiento medio. Los siguientes serían los
pasos básicos de este algoritmo:
 En primer lugar, debemos comenzar con los puntos de datos asignados a un
grupo propio.
 Ahora, calcula los centroides y actualiza la ubicación de los nuevos centroides.
 Al repetir este proceso, nos acercamos al pico del clúster, es decir, hacia la región
de mayor densidad.
 Este algoritmo se detiene en la etapa donde los centroides ya no se mueven.
Con la ayuda del siguiente código, estamos implementando el algoritmo de
agrupación Mean Shift en Python. Vamos a utilizar el módulo Scikit-learn.
Importemos los paquetes necesarios:
import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")

El siguiente código ayudará a generar el conjunto de datos bidimensional, que

contiene cuatro blobs, utilizando make_blob del paquete sklearn.dataset .
from sklearn.datasets.samples_generator import make_blobs
Podemos visualizar el conjunto de datos con el siguiente código
centers = [[2,2],[4,5],[3,10]]
X, _ = make_blobs(n_samples = 500, centers = centers,
cluster_std = 1)
plt.scatter(X[:,0],X[:,1])
plt.show()

Ahora, tenemos que entrenar el modelo de clúster Mean Shift con los datos de
entrada.
ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
El siguiente código imprimirá los centros de clúster y el número esperado de
clúster según los datos de entrada:
print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
[[ 3.23005036 3.84771893]
[ 3.02057451 9.88928991]]
Estimated clusters: 2

El código que se proporciona a continuación ayudará a trazar y visualizar los

hallazgos de la máquina en función de nuestros datos y el ajuste de acuerdo
con el número de grupos que se encontrarán.
colors = 10*['r.','g.','b.','c.','k.','y.','m.']
for i in range(len(X)):
plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize =
10)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
 marker = "x",color = 'k', s = 150, linewidths = 5, zorder
= 10)
plt.show()

Medición del rendimiento de agrupamiento

Los datos del mundo real no están organizados naturalmente en varios grupos
distintivos. Debido a esta razón, no es fácil visualizar y sacar inferencias. Es
por eso que necesitamos medir el rendimiento de la agrupación, así como su
calidad. Se puede hacer con la ayuda del análisis de silueta.

Análisis de silueta

Este método se puede usar para verificar la calidad de la agrupación midiendo

la distancia entre las agrupaciones. Básicamente, proporciona una forma de
evaluar los parámetros, como el número de grupos, al dar una puntuación de
silueta. Este puntaje es una métrica que mide qué tan cerca está cada punto
en un grupo a los puntos en los grupos vecinos.

Análisis de puntaje de silueta

El puntaje tiene un rango de [-1, 1]. El siguiente es el análisis de esta

puntuación:
 Puntaje de +1 : el puntaje cercano a +1 indica que la muestra está muy lejos del
grupo vecino.
 Puntuación de 0 : la puntuación de 0 indica que la muestra está en o muy cerca
del límite de decisión entre dos grupos vecinos.
 Puntuación de -1 : la puntuación negativa indica que las muestras se han
asignado a los grupos incorrectos.
Cálculo de puntaje de silueta
En esta sección, aprenderemos cómo calcular la puntuación de la silueta.
La puntuación de silueta se puede calcular mediante la siguiente fórmula:
$$ puntuación de silueta = \ frac {\ left (pq \ right)} {max \ left (p, q \ right)} $$
Aquí, 𝑝 es la distancia media a los puntos en el grupo más cercano del que el
punto de datos no forma parte. Y, 𝑞 es la distancia media dentro del grupo a
todos los puntos en su propio grupo.
Para encontrar el número óptimo de clústeres, necesitamos ejecutar el
algoritmo de clúster nuevamente importando el módulo
de métricas del paquete sklearn . En el siguiente ejemplo, ejecutaremos el
algoritmo de agrupación de K-means para encontrar el número óptimo de
agrupaciones:
Importe los paquetes necesarios como se muestra:
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

Con la ayuda del siguiente código, generaremos el conjunto de datos

bidimensional, que contiene cuatro blobs,
utilizando make_blob del paquete sklearn.dataset .
from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4,

cluster_std = 0.40, random_state = 0)

Inicialice las variables como se muestra:

scores = []
values = np.arange(2, 10)
Necesitamos iterar el modelo K-means a través de todos los valores y también
debemos entrenarlo con los datos de entrada.
for num_clusters in values:
kmeans = KMeans(init = 'k-means++', n_clusters =
num_clusters, n_init = 10)
kmeans.fit(X)
Ahora, calcule la puntuación de la silueta para el modelo de agrupamiento
actual utilizando la métrica de distancia euclidiana:
score = metrics.silhouette_score(X, kmeans.labels_,
metric = 'euclidean', sample_size = len(X))
La siguiente línea de código ayudará a mostrar la cantidad de clústeres y la
puntuación de Silhouette.
print("\nNumber of clusters =", num_clusters)
print("Silhouette score =", score)
scores.append(score)
Recibirá el siguiente resultado:
Number of clusters = 9
Silhouette score = 0.340391138371

num_clusters = np.argmax(scores) + values[0]

print('\nOptimal number of clusters =', num_clusters)
Ahora, la salida para un número óptimo de grupos sería la siguiente:
Optimal number of clusters = 2

Encontrar vecinos más cercanos

Si queremos construir sistemas de recomendación, como un sistema de
recomendación de películas, entonces debemos entender el concepto de
encontrar los vecinos más cercanos. Esto se debe a que el sistema de
recomendación utiliza el concepto de vecinos más cercanos.
El concepto de encontrar vecinos más cercanos puede definirse como el
proceso de encontrar el punto más cercano al punto de entrada desde el
conjunto de datos dado. El uso principal de este algoritmo KNN (vecinos más
cercanos K) es construir sistemas de clasificación que clasifiquen un punto de
datos en la proximidad del punto de datos de entrada a varias clases.
El código de Python que se proporciona a continuación ayuda a encontrar los
vecinos K más cercanos de un conjunto de datos dado:
Importe los paquetes necesarios como se muestra a continuación. En este
caso, estamos usando el NearestNeighbors módulo de la sklearn paquete
import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors
Ahora definamos los datos de entrada:
A = np.array([[3.1, 2.3], [2.3, 4.2], [3.9, 3.5], [3.7, 6.4],
[4.8, 1.9],
[8.3, 3.1], [5.2, 7.5], [4.8, 4.7], [3.5, 5.1],
[4.4, 2.9],])
Ahora, necesitamos definir los vecinos más cercanos:
k = 3
También debemos proporcionar los datos de prueba a partir de los cuales se
encuentran los vecinos más cercanos:
test_data = [3.3, 2.9]
El siguiente código puede visualizar y trazar los datos de entrada definidos por
nosotros:
plt.figure()
plt.title('Input data')
plt.scatter(A[:,0], A[:,1], marker = 'o', s = 100, color =
'black')

Ahora, necesitamos construir el vecino K más cercano. El objeto también

necesita ser entrenado
knn_model = NearestNeighbors(n_neighbors = k, algorithm =
'auto').fit(X)
distances, indices = knn_model.kneighbors([test_data])
Ahora, podemos imprimir los K vecinos más cercanos de la siguiente manera
print("\nK Nearest Neighbors:")
for rank, index in enumerate(indices[0][:k], start = 1):
print(str(rank) + " is", A[index])

Podemos visualizar los vecinos más cercanos junto con el punto de datos de
prueba.
plt.figure()
plt.title('Nearest neighbors')
plt.scatter(A[:, 0], X[:, 1], marker = 'o', s = 100, color =
'k')
plt.scatter(A[indices][0][:][:, 0], A[indices][0][:][:, 1],
marker = 'o', s = 250, color = 'k', facecolors = 'none')
plt.scatter(test_data[0], test_data[1],
marker = 'x', s = 100, color = 'k')
plt.show()
Salida

K vecinos más cercanos

1 is [ 3.1 2.3]
2 is [ 3.9 3.5]
3 is [ 4.4 2.9]

Clasificador de Vecinos K-Nearest

Un clasificador de Vecinos K-Nearest (KNN) es un modelo de clasificación que
utiliza el algoritmo de vecinos más cercanos para clasificar un punto de datos
dado. Hemos implementado el algoritmo KNN en la última sección, ahora
vamos a construir un clasificador KNN usando ese algoritmo.

Concepto de clasificador KNN

El concepto básico de la clasificación del vecino K más cercano es encontrar

un número predefinido, es decir, la 'k' - de las muestras de entrenamiento más
cercanas en distancia a una nueva muestra, que debe clasificarse. Las nuevas
muestras recibirán su etiqueta de los propios vecinos. Los clasificadores KNN
tienen una constante fija definida por el usuario para el número de vecinos que
deben determinarse. Para la distancia, la distancia euclidiana estándar es la
opción más común. El Clasificador KNN trabaja directamente en las muestras
aprendidas en lugar de crear las reglas para el aprendizaje. El algoritmo KNN
se encuentra entre los algoritmos de aprendizaje automático más simples. Ha
tenido bastante éxito en una gran cantidad de problemas de clasificación y
regresión, por ejemplo, reconocimiento de caracteres o análisis de imágenes.
Ejemplo
Estamos construyendo un clasificador KNN para reconocer dígitos. Para esto,
utilizaremos el conjunto de datos MNIST. Escribiremos este código en el
cuaderno Jupyter.
Importe los paquetes necesarios como se muestra a continuación.
Aquí estamos usando el KNeighborsClassifier módulo de
la sklearn.neighbors paquete -
from sklearn.datasets import *
import pandas as pd
%matplotlib inline
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
import numpy as np

El siguiente código mostrará la imagen del dígito para verificar qué imagen
tenemos que probar:
def Image_display(i):
plt.imshow(digit['images'][i],cmap = 'Greys_r')
plt.show()
Ahora, necesitamos cargar el conjunto de datos MNIST. En realidad, hay un
total de 1797 imágenes, pero estamos utilizando las primeras 1600 imágenes
como muestra de entrenamiento y las 197 restantes se conservarán para fines
de prueba.
digit = load_digits()
digit_d = pd.DataFrame(digit['data'][0:1600])

Ahora, al mostrar las imágenes, podemos ver la salida de la siguiente manera:

Image_display(0)

Imagen_display (0)

La imagen de 0 se muestra de la siguiente manera:

Imagen_display (9)
La imagen de 9 se muestra de la siguiente manera:

digit.keys ()

Ahora, necesitamos crear el conjunto de datos de entrenamiento y prueba y

suministrar el conjunto de datos de prueba a los clasificadores KNN.
train_x = digit['data'][:1600]
train_y = digit['target'][:1600]
KNN = KNeighborsClassifier(20)
KNN.fit(train_x,train_y)

El siguiente resultado creará el constructor de clasificador vecino K más

cercano:
KNeighborsClassifier(algorithm = 'auto', leaf_size = 30,
metric = 'minkowski',
metric_params = None, n_jobs = 1, n_neighbors = 20, p = 2,
weights = 'uniform')
Necesitamos crear la muestra de prueba proporcionando cualquier número
arbitrario mayor que 1600, que fueron las muestras de entrenamiento.
test = np.array(digit['data'][1725])
test1 = test.reshape(1,-1)
Image_display(1725)

Imagen_display (6)

La imagen de 6 se muestra de la siguiente manera:

Ahora predeciremos los datos de prueba de la siguiente manera:
KNN.predict(test1)
El código anterior generará el siguiente resultado:
array([6])
Ahora, considere lo siguiente:
digit['target_names']
El código anterior generará el siguiente resultado:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
AI con Python - Procesamiento de lenguaje
natural
El procesamiento del lenguaje natural (PNL) se refiere al método de
inteligencia artificial para comunicarse con sistemas inteligentes que utilizan
un lenguaje natural como el inglés.
El procesamiento del lenguaje natural es necesario cuando desea que un
sistema inteligente como un robot funcione según sus instrucciones, cuando
desea escuchar la decisión de un sistema de expertos clínicos basado en el
diálogo, etc.
El campo de la PNL implica hacer que las computadoras realicen tareas útiles
con los lenguajes naturales que usan los humanos. La entrada y salida de un
sistema PNL puede ser:

 Habla
 Texto escrito

Componentes de PNL
En esta sección, aprenderemos sobre los diferentes componentes de
PNL. Hay dos componentes de PNL. Los componentes se describen a
continuación:

Comprensión del lenguaje natural (NLU)

Implica las siguientes tareas:
 Mapear la entrada dada en lenguaje natural en representaciones útiles.
 Analizando diferentes aspectos del lenguaje.

Generación de lenguaje natural (NLG)

Es el proceso de producir frases y oraciones significativas en forma de

lenguaje natural a partir de alguna representación interna. Implica
 Planificación de texto : esto incluye recuperar el contenido relevante de la base
de conocimiento.
 Planificación de oraciones : esto incluye elegir las palabras requeridas, formar
frases significativas y establecer el tono de la oración.
 Realización de texto : este es el mapeo del plan de oración en la estructura de la
oración.

Dificultades en NLU
La NLU es muy rica en forma y estructura; Sin embargo, es ambiguo. Puede
haber diferentes niveles de ambigüedad:

Ambigüedad léxica

Está en un nivel muy primitivo, como el nivel de palabra. Por ejemplo, ¿trata la
palabra "tablero" como sustantivo o verbo?

Nivel de sintaxis ambigüedad

Una oración se puede analizar de diferentes maneras. Por ejemplo, "Levantó

el escarabajo con gorra roja". ¿Utilizó la gorra para levantar el escarabajo o
levantó un escarabajo que tenía gorra roja?

Ambigüedad referencial

Refiriéndose a algo usando pronombres. Por ejemplo, Rima fue a Gauri. Ella
dijo: "Estoy cansada". ¿Exactamente quién está cansada?

Terminología de PNL
Veamos ahora algunos términos importantes en la terminología de PNL.
 Fonología - Es el estudio de organizar el sonido sistemáticamente.
 Morfología : es un estudio de construcción de palabras a partir de unidades
primitivas significativas.
 Morfema : es una unidad primitiva de significado en un idioma.
 Sintaxis : se refiere a organizar palabras para formar una oración. También
implica determinar el papel estructural de las palabras en la oración y en las
frases.
  Semántica : se ocupa del significado de las palabras y de cómo combinar
palabras en frases y oraciones significativas.
 Pragmática : se trata de usar y comprender oraciones en diferentes situaciones y
cómo se ve afectada la interpretación de la oración.
 Discurso : trata de cómo la oración que precede inmediatamente puede afectar la
interpretación de la siguiente oración.
 Conocimiento mundial : incluye el conocimiento general sobre el mundo.

Pasos en PNL
Esta sección muestra los diferentes pasos en PNL.

Análisis léxico

Implica identificar y analizar la estructura de las palabras. El léxico de un

idioma significa la colección de palabras y frases en un idioma. El análisis
léxico está dividiendo todo el fragmento de texto en párrafos, oraciones y
palabras.

Análisis sintáctico (análisis)

Implica el análisis de las palabras en la oración para la gramática y la

organización de las palabras de una manera que muestre la relación entre las
palabras. El analizador sintáctico inglés rechaza la frase como "La escuela va
al niño".

Análisis semántico

Dibuja el significado exacto o el significado del diccionario del texto. Se verifica

que el texto sea significativo. Se realiza mediante el mapeo de estructuras
sintácticas y objetos en el dominio de la tarea. El analizador semántico no
tiene en cuenta frases como "helado caliente".

Integración del discurso

El significado de cualquier oración depende del significado de la oración justo

antes de ella. Además, también produce el significado de una oración
inmediatamente posterior.

Análisis pragmático

Durante esto, lo que se dijo se reinterpreta sobre lo que realmente

significaba. Implica derivar aquellos aspectos del lenguaje que requieren
conocimiento del mundo real.

AI con Python - Paquete NLTK

En este capítulo, aprenderemos cómo comenzar con el Paquete de
herramientas del lenguaje natural.
Requisito previo

Si queremos crear aplicaciones con procesamiento de lenguaje natural,

entonces el cambio de contexto lo hace más difícil. El factor de contexto
influye en cómo la máquina entiende una oración en particular. Por lo tanto,
necesitamos desarrollar aplicaciones de lenguaje natural mediante el uso de
enfoques de aprendizaje automático para que la máquina también pueda
comprender la forma en que un humano puede entender el contexto.
Para construir tales aplicaciones usaremos el paquete Python llamado NLTK
(Paquete de herramientas del lenguaje natural).

Importar NLTK
Necesitamos instalar NLTK antes de usarlo. Se puede instalar con la ayuda
del siguiente comando:
pip install nltk
Para construir un paquete conda para NLTK, use el siguiente comando:
conda install -c anaconda nltk
Ahora, después de instalar el paquete NLTK, debemos importarlo a través del
símbolo del sistema de Python. Podemos importarlo escribiendo el siguiente
comando en el símbolo del sistema de Python:
>>> import nltk

Descargar datos de NLTK

Ahora, después de importar NLTK, necesitamos descargar los datos
requeridos. Se puede hacer con la ayuda del siguiente comando en el símbolo
del sistema Python:
>>> nltk.download()

Instalar otros paquetes necesarios

Para construir aplicaciones de procesamiento de lenguaje natural utilizando
NLTK, necesitamos instalar los paquetes necesarios. Los paquetes son los
siguientes:

gensim

Es una biblioteca robusta de modelado semántico que es útil para muchas

aplicaciones. Podemos instalarlo ejecutando el siguiente comando:
pip install gensim

modelo
Se utiliza para hacer que el paquete gensim funcione
correctamente. Podemos instalarlo ejecutando el siguiente comando
pip install pattern

Concepto de tokenización, tallo y lematización

En esta sección, entenderemos qué es la tokenización, la derivación y la
lematización.

Tokenización

Se puede definir como el proceso de dividir el texto dado, es decir, la

secuencia de caracteres en unidades más pequeñas llamadas tokens. Las
fichas pueden ser palabras, números o signos de puntuación. También se
llama segmentación de palabras. El siguiente es un ejemplo simple de
tokenización:
Entrada - Mango, plátano, piña y manzana, todos son frutas.
Salida -

El proceso de romper el texto dado se puede hacer con la ayuda de localizar

los límites de las palabras. El final de una palabra y el comienzo de una nueva
palabra se llaman límites de palabras. El sistema de escritura y la estructura
tipográfica de las palabras influyen en los límites.
En el módulo Python NLTK, tenemos diferentes paquetes relacionados con la
tokenización que podemos usar para dividir el texto en tokens según nuestros
requisitos. Algunos de los paquetes son los siguientes:

paquete enviado_tokenize

Como su nombre indica, este paquete dividirá el texto de entrada en

oraciones. Podemos importar este paquete con la ayuda del siguiente código
de Python:
from nltk.tokenize import sent_tokenize

paquete word_tokenize

Este paquete divide el texto de entrada en palabras. Podemos importar este

paquete con la ayuda del siguiente código de Python:
from nltk.tokenize import word_tokenize

Paquete WordPunctTokenizer

Este paquete divide el texto de entrada en palabras, así como los signos de
puntuación. Podemos importar este paquete con la ayuda del siguiente código
de Python:
from nltk.tokenize import WordPuncttokenizer

Tallo

Mientras trabajamos con palabras, nos encontramos con muchas variaciones

debido a razones gramaticales. El concepto de variaciones aquí significa que
tenemos que lidiar con diferentes formas de las mismas palabras
como democracia, democracia y democratización . Es muy necesario que
las máquinas entiendan que estas diferentes palabras tienen la misma forma
básica. De esta manera, sería útil extraer las formas básicas de las palabras
mientras analizamos el texto.
Podemos lograr esto derivando. De esta manera, podemos decir que la
derivación es el proceso heurístico de extraer las formas básicas de las
palabras cortando los extremos de las palabras.
En el módulo Python NLTK, tenemos diferentes paquetes relacionados con la
derivación. Estos paquetes se pueden usar para obtener las formas básicas
de Word. Estos paquetes usan algoritmos. Algunos de los paquetes son los
siguientes:

Paquete PorterStemmer

Este paquete de Python utiliza el algoritmo de Porter para extraer el formulario

base. Podemos importar este paquete con la ayuda del siguiente código de
Python:
from nltk.stem.porter import PorterStemmer
Por ejemplo, si les damos la palabra 'escritura' como entrada para este
derivador, obtendremos la palabra 'escribir' después de la derivación.

Paquete LancasterStemmer

Este paquete de Python utilizará el algoritmo de Lancaster para extraer el

formulario base. Podemos importar este paquete con la ayuda del siguiente
código de Python:
from nltk.stem.lancaster import LancasterStemmer
Por ejemplo, si les damos la palabra 'escritura' como entrada para este
derivador, obtendremos la palabra 'escribir' después de la derivación.

Paquete SnowballStemmer

Este paquete de Python usará el algoritmo de la bola de nieve para extraer la

forma base. Podemos importar este paquete con la ayuda del siguiente código
de Python:
from nltk.stem.snowball import SnowballStemmer
Por ejemplo, si les damos la palabra 'escritura' como entrada para este
derivador, obtendremos la palabra 'escribir' después de la derivación.
Todos estos algoritmos tienen diferentes niveles de rigor. Si comparamos
estos tres stemmers, los de Porter son los menos estrictos y Lancaster es el
más estricto. Snowball stemmer es bueno para usar en términos de velocidad
y rigidez.

Lematización

También podemos extraer la forma básica de las palabras por

lematización. Básicamente realiza esta tarea con el uso de un vocabulario y un
análisis morfológico de las palabras, normalmente con el objetivo de eliminar
solo las terminaciones de inflexión. Este tipo de forma básica de cualquier
palabra se llama lema.
La principal diferencia entre la lematización y la lematización es el uso del
vocabulario y el análisis morfológico de las palabras. Otra diferencia es que la
derivación comúnmente colapsa las palabras relacionadas con la derivación,
mientras que la lematización comúnmente colapsa las diferentes formas de
inflexión de una lemma. Por ejemplo, si proporcionamos la palabra saw como
la palabra de entrada, la derivación podría devolver la palabra 's' pero la
lematización intentaría devolver la palabra ya sea see o saw dependiendo de
si el uso del token era un verbo o un sustantivo.
En el módulo Python NLTK, tenemos el siguiente paquete relacionado con el
proceso de lematización que podemos usar para obtener las formas básicas
de la palabra:

Paquete de WordNetLemmatizer

Este paquete de Python extraerá la forma base de la palabra dependiendo de

si se usa como sustantivo o como verbo. Podemos importar este paquete con
la ayuda del siguiente código de Python:
from nltk.stem import WordNetLemmatizer

Fragmentación: división de datos en fragmentos

Es uno de los procesos importantes en el procesamiento del lenguaje
natural. El trabajo principal de la fragmentación es identificar las partes del
discurso y frases cortas como frases nominales. Ya hemos estudiado el
proceso de tokenización, la creación de tokens. Bunking es básicamente el
etiquetado de esos tokens. En otras palabras, la fragmentación nos mostrará
la estructura de la oración.
En la siguiente sección, aprenderemos sobre los diferentes tipos de Chunking.

Tipos de fragmentación
Hay dos tipos de fragmentación. Los tipos son los siguientes:

Fragmentando
En este proceso de fragmentación, el objeto, las cosas, etc. pasan a ser más
generales y el lenguaje se vuelve más abstracto. Hay más posibilidades de
acuerdo. En este proceso, nos alejamos. Por ejemplo, si vamos a dividir la
pregunta de "¿para qué sirven los automóviles"? Podemos obtener la
respuesta "transporte".

Fragmentando

En este proceso de fragmentación, el objeto, las cosas, etc. se mueven hacia

ser más específicos y el lenguaje se penetra más. La estructura más profunda
sería examinada en trozos. En este proceso, nos acercamos. Por ejemplo, si
reducimos la pregunta "¿Habla específicamente sobre un
automóvil"? Obtendremos información más pequeña sobre el automóvil.
Ejemplo
En este ejemplo, haremos un fragmento de Noun-Phrase, una categoría de
fragmentación que encontrará los fragmentos de frases nominales en la
oración, utilizando el módulo NLTK en Python:
Siga estos pasos en Python para implementar la fragmentación de frases
sustantivas:
Paso 1 : en este paso, debemos definir la gramática para la
fragmentación. Consistiría en las reglas que debemos seguir.
Paso 2 : en este paso, necesitamos crear un analizador de
fragmentos. Analizaría la gramática y daría la salida.
Paso 3 : en este último paso, la salida se produce en un formato de árbol.
Importemos el paquete NLTK necesario de la siguiente manera:
import nltk

Ahora, necesitamos definir la oración. Aquí, DT significa el determinante, VBP

significa el verbo, JJ significa el adjetivo, IN significa la preposición y NN
significa el sustantivo.
sentence=[("a","DT"),("clever","JJ"),("fox","NN"),("was","VBP
"),

("jumping","VBP"),("over","IN"),("the","DT"),("wall","NN")]
Ahora, necesitamos dar la gramática. Aquí daremos la gramática en forma de
expresión regular.
grammar = "NP:{<DT>?<JJ>*<NN>}"
Necesitamos definir un analizador que analizará la gramática.
parser_chunking = nltk.RegexpParser(grammar)
El analizador analiza la oración de la siguiente manera:
parser_chunking.parse(sentence)
A continuación, necesitamos obtener la salida. La salida se genera en la
variable simple llamada output_chunk .
Output_chunk = parser_chunking.parse(sentence)
Tras la ejecución del siguiente código, podemos dibujar nuestra salida en
forma de árbol.
output.draw()

Modelo de bolsa de palabras (BoW)

Bag of Word (BoW), un modelo en el procesamiento del lenguaje natural, se
usa básicamente para extraer las características del texto para que el texto
pueda usarse en el modelado de manera tal que en algoritmos de aprendizaje
automático.
Ahora surge la pregunta de por qué necesitamos extraer las características del
texto. Esto se debe a que los algoritmos de aprendizaje automático no pueden
funcionar con datos sin procesar y necesitan datos numéricos para poder
extraer información significativa de ellos. La conversión de datos de texto en
datos numéricos se denomina extracción de características o codificación de
características.

Cómo funciona

Este es un enfoque muy simple para extraer las características del

texto. Supongamos que tenemos un documento de texto y queremos
convertirlo en datos numéricos o decir que queremos extraer las
características de él y, en primer lugar, este modelo extrae un vocabulario de
todas las palabras del documento. Luego, mediante el uso de una matriz de
términos del documento, creará un modelo. De esta manera, BoW representa
el documento solo como una bolsa de palabras. Cualquier información sobre
el orden o la estructura de las palabras en el documento se descarta.

Concepto de matriz de términos del documento

El algoritmo BoW construye un modelo utilizando la matriz de términos del

documento. Como su nombre indica, la matriz de términos del documento es
la matriz de varios recuentos de palabras que se producen en el
documento. Con la ayuda de esta matriz, el documento de texto puede
representarse como una combinación ponderada de varias palabras. Al
establecer el umbral y elegir las palabras que son más significativas, podemos
construir un histograma de todas las palabras en los documentos que se
pueden usar como un vector de características. El siguiente es un ejemplo
para comprender el concepto de matriz de términos del documento:
Ejemplo
Supongamos que tenemos las siguientes dos oraciones:
 Oración 1 - Estamos usando el modelo Bolsa de palabras.
 El modelo Oración 2 - Bolsa de palabras se utiliza para extraer las características.
Ahora, al considerar estas dos oraciones, tenemos las siguientes 13 palabras
distintas:

 nosotros
 son
 utilizando
 el
 bolso
 de
 palabras
 modelo
 es
 usado
 para
 extracción
 caracteristicas
Ahora, necesitamos construir un histograma para cada oración usando el
conteo de palabras en cada oración:
 Oración 1 - [1,1,1,1,1,1,1,1,0,0,0,0,0]
 Oración 2 - [0,0,0,1,1,1,1,1,1,1,1,1,1]
De esta manera, tenemos los vectores de características que se han
extraído. Cada vector de características es de 13 dimensiones porque
tenemos 13 palabras distintas.

Concepto de la estadística
El concepto de las estadísticas se llama Frecuencia de documento inversa de
frecuencia de término (tf-idf). Cada palabra es importante en el
documento. Las estadísticas nos ayudan a comprender la importancia de cada
palabra.

Término Frecuencia (tf)

Es la medida de la frecuencia con la que cada palabra aparece en un
documento. Se puede obtener dividiendo el recuento de cada palabra por el
número total de palabras en un documento dado.

Frecuencia de documento inversa (idf)

Es la medida de cuán única es una palabra para este documento en el

conjunto dado de documentos. Para calcular idf y formular un vector
característico distintivo, necesitamos reducir el peso de las palabras comunes
como el y sopesar las palabras raras.

Construyendo un modelo de bolsa de palabras en

NLTK
En esta sección, definiremos una colección de cadenas usando
CountVectorizer para crear vectores a partir de estas oraciones.
Importemos el paquete necesario:
from sklearn.feature_extraction.text import CountVectorizer
Ahora defina el conjunto de oraciones.
Sentences = ['We are using the Bag of Word model', 'Bag of
Word model is
used for extracting the features.']

vectorizer_count = CountVectorizer()

features_text = vectorizer.fit_transform(Sentences).todense()

print(vectorizer.vocabulary_)

El programa anterior genera la salida como se muestra a

continuación. Muestra que tenemos 13 palabras distintas en las dos oraciones
anteriores:
{'we': 11, 'are': 0, 'using': 10, 'the': 8, 'bag': 1, 'of':
7,
'word': 12, 'model': 6, 'is': 5, 'used': 9, 'for': 4,
'extracting': 2, 'features': 3}
Estos son los vectores de características (texto a forma numérica) que se
pueden utilizar para el aprendizaje automático.

Resolviendo problemas
En esta sección, resolveremos algunos problemas relacionados.

Predicción de categoría
En un conjunto de documentos, no solo son importantes las palabras, sino
también la categoría de las palabras; en qué categoría de texto cae una
palabra en particular. Por ejemplo, queremos predecir si una oración dada
pertenece a la categoría correo electrónico, noticias, deportes, computadora,
etc. En el siguiente ejemplo, vamos a usar tf-idf para formular un vector de
características para encontrar la categoría de documentos. Utilizaremos los
datos del conjunto de datos de 20 grupos de noticias de sklearn.
Necesitamos importar los paquetes necesarios:
from sklearn.datasets import fetch_20newsgroups
from sklearn.naive_bayes import MultinomialNB
from sklearn.feature_extraction.text import TfidfTransformer
from sklearn.feature_extraction.text import CountVectorizer
Definir el mapa de categoría. Estamos utilizando cinco categorías diferentes
llamadas Religión, Autos, Deportes, Electrónica y Espacio.
category_map =
{'talk.religion.misc':'Religion','rec.autos''Autos',

'rec.sport.hockey':'Hockey','sci.electronics':'Electronics',
'sci.space': 'Space'}

Crea el conjunto de entrenamiento -

training_data = fetch_20newsgroups(subset = 'train',
categories = category_map.keys(), shuffle = True,
random_state = 5)
Cree un vectorizador de recuento y extraiga el término recuentos:
vectorizer_count = CountVectorizer()
train_tc = vectorizer_count.fit_transform(training_data.data)
print("\nDimensions of training data:", train_tc.shape)

El transformador tf-idf se crea de la siguiente manera:

tfidf = TfidfTransformer()
train_tfidf = tfidf.fit_transform(train_tc)

Ahora, defina los datos de prueba:

input_data = [
'Discovery was a space shuttle',
'Hindu, Christian, Sikh all are religions',
'We must have to drive safely',
'Puck is a disk made of rubber',
'Television, Microwave, Refrigrated all uses electricity'
]
Los datos anteriores nos ayudarán a entrenar un clasificador de Bayes
ingenuo multinomial:
classifier = MultinomialNB().fit(train_tfidf,
training_data.target)
Transforme los datos de entrada usando el vectorizador de conteo -
input_tc = vectorizer_count.transform(input_data)
Ahora, transformaremos los datos vectorizados usando el transformador tfidf:
input_tfidf = tfidf.transform(input_tc)

Vamos a predecir las categorías de salida:

predictions = classifier.predict(input_tfidf)
La salida se genera de la siguiente manera:
for sent, category in zip(input_data, predictions):
print('\nInput Data:', sent, '\n Category:', \
category_map[training_data.target_names[category]])
El predictor de categoría genera el siguiente resultado:
Dimensions of training data: (2755, 39297)

Input Data: Discovery was a space shuttle

Category: Space

Input Data: Hindu, Christian, Sikh all are religions

Category: Religion

Input Data: We must have to drive safely

Category: Autos

Input Data: Puck is a disk made of rubber

Category: Hockey

Input Data: Television, Microwave, Refrigrated all uses

electricity
Category: Electronics

Buscador de género

En esta declaración del problema, un clasificador sería entrenado para

encontrar el género (masculino o femenino) proporcionando los
nombres. Necesitamos usar una heurística para construir un vector de
características y entrenar al clasificador. Utilizaremos los datos etiquetados del
paquete scikit-learn. El siguiente es el código de Python para construir un
buscador de género:
Importemos los paquetes necesarios:
import random

from nltk import NaiveBayesClassifier

from nltk.classify import accuracy as nltk_accuracy
from nltk.corpus import names

Ahora necesitamos extraer las últimas N letras de la palabra de entrada. Estas

letras actuarán como características:
def extract_features(word, N = 2):
last_n_letters = word[-N:]
return {'feature': last_n_letters.lower()}

if __name__=='__main__':

Cree los datos de entrenamiento utilizando nombres etiquetados (masculino y

femenino) disponibles en NLTK -
male_list = [(name, 'male') for name in
names.words('male.txt')]
female_list = [(name, 'female') for name in
names.words('female.txt')]
data = (male_list + female_list)

random.seed(5)
random.shuffle(data)

Ahora, los datos de prueba se crearán de la siguiente manera:

namesInput = ['Rajesh', 'Gaurav', 'Swati', 'Shubha']
Defina el número de muestras utilizadas para entrenar y probar con el
siguiente código
train_sample = int(0.8 * len(data))

Ahora, necesitamos iterar a través de diferentes longitudes para poder

comparar la precisión.
for i in range(1, 6):
print('\nNumber of end letters:', i)
features = [(extract_features(n, i), gender) for (n,
gender) in data]
train_data, test_data = features[:train_sample],
features[train_sample:]
classifier = NaiveBayesClassifier.train(train_data)
La precisión del clasificador se puede calcular de la siguiente manera:
accuracy_classifier = round(100 * nltk_accuracy(classifier,
test_data), 2)
print('Accuracy = ' + str(accuracy_classifier) + '%')

Ahora, podemos predecir la salida:

for name in namesInput:
print(name, '==>',
classifier.classify(extract_features(name, i)))
El programa anterior generará el siguiente resultado:
Number of end letters: 1
Accuracy = 74.7%
Rajesh -> female
Gaurav -> male
Swati -> female
Shubha -> female

Number of end letters: 2

Accuracy = 78.79%
Rajesh -> male
Gaurav -> male
Swati -> female
Shubha -> female

Number of end letters: 3

Accuracy = 77.22%
Rajesh -> male
Gaurav -> female
Swati -> female
Shubha -> female

Number of end letters: 4

Accuracy = 69.98%
Rajesh -> female
Gaurav -> female
Swati -> female
Shubha -> female

Number of end letters: 5

Accuracy = 64.63%
Rajesh -> female
Gaurav -> female
Swati -> female
Shubha -> female
En el resultado anterior, podemos ver que la precisión en el número máximo
de letras finales es dos y está disminuyendo a medida que aumenta el número
de letras finales.

Modelado de temas: identificación de patrones en

datos de texto
Sabemos que, en general, los documentos se agrupan en temas. A veces
necesitamos identificar los patrones en un texto que corresponden a un tema
en particular. La técnica de hacer esto se llama modelado de temas. En otras
palabras, podemos decir que el modelado de temas es una técnica para
descubrir temas abstractos o estructuras ocultas en el conjunto de
documentos dado.
Podemos usar la técnica de modelado de temas en los siguientes escenarios:

Clasificación de texto

Con la ayuda del modelado de temas, la clasificación se puede mejorar porque

agrupa palabras similares en lugar de usar cada palabra por separado como
una característica.
Sistemas de recomendación

Con la ayuda del modelado de temas, podemos construir los sistemas de

recomendación utilizando medidas de similitud.

Algoritmos para el modelado de temas

El modelado de temas se puede implementar mediante el uso de
algoritmos. Los algoritmos son los siguientes:

Asignación de Dirichlet Latente (LDA)

Este algoritmo es el más popular para el modelado de temas. Utiliza los

modelos gráficos probabilísticos para implementar el modelado de
temas. Necesitamos importar el paquete gensim en Python para usar el
slgorithm de LDA.

Análisis semántico latente (LDA) o indexación semántica latente (LSI)

Este algoritmo se basa en álgebra lineal. Básicamente utiliza el concepto de

SVD (Descomposición de valor singular) en la matriz de términos del
documento.

Factorización de matriz no negativa (NMF)

También se basa en álgebra lineal.

Todos los algoritmos mencionados anteriormente para el modelado de temas
tendrían el número de temas como un parámetro, Document-Word
Matrix como entrada y WTM (Word Topic Matrix) y TDM (Topic Document
Matrix) como salida.

AI con Python: análisis de datos de series

temporales
Predecir el siguiente en una secuencia de entrada dada es otro concepto
importante en el aprendizaje automático. Este capítulo le brinda una
explicación detallada sobre el análisis de datos de series temporales.

Introducción
Datos de series de tiempo significa los datos que se encuentran en una serie
de intervalos de tiempo particulares. Si queremos construir predicciones de
secuencia en el aprendizaje automático, entonces tenemos que lidiar con
datos secuenciales y tiempo. Los datos en serie son un resumen de datos
secuenciales. El pedido de datos es una característica importante de los datos
secuenciales.
Concepto básico de análisis de secuencia o análisis de series de
tiempo

El análisis de secuencia o análisis de series de tiempo es para predecir el

siguiente en una secuencia de entrada dada en base a lo observado
previamente. La predicción puede ser cualquier cosa que pueda venir a
continuación: un símbolo, un número, el clima del día siguiente, el próximo
término en el habla, etc. El análisis de secuencia puede ser muy útil en
aplicaciones como el análisis del mercado de valores, el pronóstico del tiempo
y las recomendaciones de productos.
Ejemplo
Considere el siguiente ejemplo para comprender la predicción de
secuencia. Aquí A, B, C, D son los valores dados y usted tiene que predecir el
valor E usando un Modelo de Predicción de Secuencia.

Instalar paquetes útiles

Para el análisis de datos de series de tiempo usando Python, necesitamos
instalar los siguientes paquetes:

Pandas

Pandas es una biblioteca de código abierto con licencia BSD que proporciona
herramientas de alto rendimiento y facilidad de uso de estructura de datos y
análisis de datos para Python. Puede instalar Pandas con la ayuda del
siguiente comando:
pip install pandas
Si está utilizando Anaconda y desea instalar mediante el administrador
de paquetes de conda , puede usar el siguiente comando:
conda install -c anaconda pandas

hmmlearn
Es una biblioteca de código abierto con licencia BSD que consta de algoritmos
y modelos simples para aprender Modelos ocultos de Markov (HMM) en
Python. Puede instalarlo con la ayuda del siguiente comando:
pip install hmmlearn
Si está utilizando Anaconda y desea instalar mediante el administrador
de paquetes de conda , puede usar el siguiente comando:
conda install -c omnia hmmlearn
PyStruct

Es una biblioteca estructurada de aprendizaje y predicción. Los algoritmos de

aprendizaje implementados en PyStruct tienen nombres como campos
aleatorios condicionales (CRF), redes aleatorias de Markov de margen
máximo (M3N) o máquinas de vectores de soporte estructural. Puede
instalarlo con la ayuda del siguiente comando:
pip install pystruct

CVXOPT

Se utiliza para la optimización convexa basada en el lenguaje de

programación Python. También es un paquete de software gratuito. Puede
instalarlo con la ayuda del siguiente comando:
pip install cvxopt
Si está utilizando Anaconda y desea instalar mediante el administrador
de paquetes de conda , puede usar el siguiente comando:
conda install -c anaconda cvdoxt

Pandas: manejo, corte y extracción de estadísticas de

datos de series temporales
Pandas es una herramienta muy útil si tiene que trabajar con datos de series
de tiempo. Con la ayuda de Pandas, puede realizar lo siguiente:
 Cree un rango de fechas utilizando el paquete pd.date_range
 Indice pandas con fechas utilizando el paquete pd.Series
 Realice un nuevo muestreo utilizando el paquete ts.resample
 Cambiar la frecuencia

Ejemplo

El siguiente ejemplo muestra cómo manejar y segmentar los datos de series

de tiempo utilizando Pandas. Tenga en cuenta que aquí estamos utilizando los
datos mensuales de la Oscilación del Ártico, que se pueden descargar
de Monthly.ao.index.b50.current.ascii y se pueden convertir a formato de texto
para nuestro uso.

Manejo de datos de series de tiempo

Para manejar datos de series temporales, deberá realizar los siguientes

pasos:
El primer paso consiste en importar los siguientes paquetes:
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
A continuación, defina una función que leerá los datos del archivo de entrada,
como se muestra en el código siguiente:
def read_data(input_file):
input_data = np.loadtxt(input_file, delimiter = None)
Ahora, convierta estos datos a series de tiempo. Para esto, cree el rango de
fechas de nuestras series de tiempo. En este ejemplo, mantenemos un mes
como frecuencia de datos. Nuestro archivo tiene los datos que comienzan en
enero de 1950.
dates = pd.date_range('1950-01', periods =
input_data.shape[0], freq = 'M')
En este paso, creamos los datos de series temporales con la ayuda de
Pandas Series, como se muestra a continuación:
output = pd.Series(input_data[:, index], index = dates)
return output

if __name__=='__main__':
Ingrese la ruta del archivo de entrada como se muestra aquí:
input_file = "/Users/admin/AO.txt"
Ahora, convierta la columna al formato de serie temporal, como se muestra
aquí:
timeseries = read_data(input_file)
Finalmente, grafica y visualiza los datos, usando los comandos que se
muestran:
plt.figure()
timeseries.plot()
plt.show()
Observará las parcelas como se muestra en las siguientes imágenes:
Cortando datos de series de tiempo

La división implica recuperar solo una parte de los datos de la serie

temporal. Como parte del ejemplo, estamos dividiendo los datos solo desde
1980 hasta 1990. Observe el siguiente código que realiza esta tarea:
timeseries['1980':'1990'].plot()
<matplotlib.axes._subplots.AxesSubplot at 0xa0e4b00>

plt.show()
Cuando ejecuta el código para segmentar los datos de series temporales,
puede observar el siguiente gráfico como se muestra en la imagen aquí:

Extraer estadística de datos de series temporales

Tendrá que extraer algunas estadísticas de una información dada, en los
casos en que necesite sacar alguna conclusión importante. La media, la
varianza, la correlación, el valor máximo y el valor mínimo son algunas de
esas estadísticas. Puede usar el siguiente código si desea extraer tales
estadísticas de una serie de datos dada:

Media

Puede usar la función mean () , para encontrar la media, como se muestra

aquí:
timeseries.mean()
Entonces el resultado que observará para el ejemplo discutido es:
-0.11143128165238671

Máximo

Puede usar la función max () , para encontrar el máximo, como se muestra

aquí:
timeseries.max()
Entonces el resultado que observará para el ejemplo discutido es:
3.4952999999999999
Mínimo

Puede usar la función min (), para encontrar el mínimo, como se muestra aquí:
timeseries.min()
Entonces el resultado que observará para el ejemplo discutido es:
-4.2656999999999998

Conseguir todo a la vez

Si desea calcular todas las estadísticas a la vez, puede usar la

función describe () como se muestra aquí:
timeseries.describe()
Entonces el resultado que observará para el ejemplo discutido es:
count 817.000000
mean -0.111431
std 1.003151
min -4.265700
25% -0.649430
50% -0.042744
75% 0.475720
max 3.495300
dtype: float64

Re-muestreo

Puede volver a muestrear los datos a una frecuencia de tiempo diferente. Los
dos parámetros para realizar un nuevo muestreo son:

 Periodo de tiempo
 Método

Re-muestreo con media ()

Puede usar el siguiente código para volver a muestrear los datos con el
método mean (), que es el método predeterminado:
timeseries_mm = timeseries.resample("A").mean()
timeseries_mm.plot(style = 'g--')
plt.show()

Luego, puede observar el siguiente gráfico como la salida del remuestreo

usando mean () -
Re-muestreo con mediana ()

Puede usar el siguiente código para volver a muestrear los datos utilizando
el método median () :
timeseries_mm = timeseries.resample("A").median()
timeseries_mm.plot()
plt.show()
Luego, puede observar el siguiente gráfico como el resultado de volver a
muestrear con mediana () -
Media móvil

Puede usar el siguiente código para calcular la media móvil (móvil):

timeseries.rolling(window = 12, center =
False).mean().plot(style = '-g')
plt.show()
Luego, puede observar el siguiente gráfico como la salida de la media móvil
(en movimiento):

Análisis de datos secuenciales por modelo oculto de

Markov (HMM)
HMM es un modelo estadístico que se usa ampliamente para datos que tienen
continuación y extensibilidad, como análisis de series de tiempo, análisis de
salud y reconocimiento de voz. Esta sección trata en detalle el análisis de
datos secuenciales utilizando el modelo oculto de Markov (HMM).

Modelo oculto de Markov (HMM)

HMM es un modelo estocástico que se basa en el concepto de cadena de

Markov basado en el supuesto de que la probabilidad de estadísticas futuras
depende solo del estado actual del proceso y no de cualquier estado que lo
haya precedido. Por ejemplo, al lanzar una moneda, no podemos decir que el
resultado del quinto lanzamiento será una cabeza. Esto se debe a que una
moneda no tiene memoria y el siguiente resultado no depende del resultado
anterior.
Matemáticamente, HMM consta de las siguientes variables:
Estados (S)

Es un conjunto de estados ocultos o latentes presentes en un HMM. Es

denotado por S.

Símbolos de salida (O)

Es un conjunto de posibles símbolos de salida presentes en un HMM. Se

denota por O.

Matriz de probabilidad de transición de estado (A)

Es la probabilidad de hacer la transición de un estado a cada uno de los otros

estados. Es denotado por A.

Matriz de probabilidad de emisión de observación (B)

Es la probabilidad de emitir / observar un símbolo en un estado particular. Es

denotado por B.

Matriz de probabilidad previa (Π)

Es la probabilidad de comenzar en un estado particular desde varios estados

del sistema. Se denota por Π.
Por lo tanto, un HMM puede definirse como 𝝀 = (S, O, A, B, 𝝅) ,
dónde,

 S = {s 1 , s 2 , ..., s N } es un conjunto de N estados posibles,

 O = {o 1 , o 2 , ..., o M } es un conjunto de M posibles símbolos de observación,
 A es una matriz de probabilidad de transición del estado N )N (TPM),
 B es una observación N𝒙M o matriz de probabilidad de emisión (EPM),
 π es un vector de distribución de probabilidad de estado inicial N dimensional.

Ejemplo: análisis de datos del mercado de valores

En este ejemplo, vamos a analizar los datos del mercado de valores, paso a
paso, para tener una idea de cómo funciona el HMM con datos secuenciales o
de series de tiempo. Tenga en cuenta que estamos implementando este
ejemplo en Python.
Importe los paquetes necesarios como se muestra a continuación:
import datetime
import warnings
Ahora, use los datos del mercado de valores del paquete matpotlib.finance ,
como se muestra aquí:
import numpy as np
from matplotlib import cm, pyplot as plt
from matplotlib.dates import YearLocator, MonthLocator
try:
from matplotlib.finance import
quotes_historical_yahoo_och1
except ImportError:
from matplotlib.finance import (
quotes_historical_yahoo as
quotes_historical_yahoo_och1)

from hmmlearn.hmm import GaussianHMM

Cargue los datos de una fecha de inicio y una fecha de finalización, es decir,
entre dos fechas específicas como se muestra aquí:
start_date = datetime.date(1995, 10, 10)
end_date = datetime.date(2015, 4, 25)
quotes = quotes_historical_yahoo_och1('INTC', start_date,
end_date)
En este paso, extraeremos las cotizaciones de cierre todos los días. Para esto,
use el siguiente comando:
closing_quotes = np.array([quote[2] for quote in quotes])
Ahora, extraeremos el volumen de acciones negociadas todos los días. Para
esto, use el siguiente comando:
volumes = np.array([quote[5] for quote in quotes])[1:]
Aquí, tome la diferencia porcentual de los precios de cierre de acciones,
utilizando el código que se muestra a continuación:
diff_percentages = 100.0 * np.diff(closing_quotes) /
closing_quotes[:-]
dates = np.array([quote[0] for quote in quotes], dtype =
np.int)[1:]
training_data = np.column_stack([diff_percentages, volumes])
En este paso, cree y entrene el Gaussian HMM. Para esto, use el siguiente
código:
hmm = GaussianHMM(n_components = 7, covariance_type = 'diag',
n_iter = 1000)
with warnings.catch_warnings():
warnings.simplefilter('ignore')
hmm.fit(training_data)
Ahora, genere datos utilizando el modelo HMM, utilizando los comandos que
se muestran:
num_samples = 300
samples, _ = hmm.sample(num_samples)
Finalmente, en este paso, graficamos y visualizamos el porcentaje de
diferencia y el volumen de acciones negociadas como salida en forma de
gráfico.
Use el siguiente código para trazar y visualizar los porcentajes de diferencia:
plt.figure()
plt.title('Difference percentages')
plt.plot(np.arange(num_samples), samples[:, 0], c = 'black')
Use el siguiente código para trazar y visualizar el volumen de acciones
negociadas:
plt.figure()
plt.title('Volume of shares')
plt.plot(np.arange(num_samples), samples[:, 1], c = 'black')
plt.ylim(ymin = 0)
plt.show()

AI con Python - Reconocimiento de voz

En este capítulo, aprenderemos sobre el reconocimiento de voz usando AI con
Python.
El habla es el medio más básico de comunicación humana adulta. El objetivo
básico del procesamiento del habla es proporcionar una interacción entre un
humano y una máquina.
El sistema de procesamiento de voz tiene principalmente tres tareas:
 Primero , el reconocimiento de voz que permite a la máquina captar las palabras,
frases y oraciones que hablamos
 Segundo , el procesamiento del lenguaje natural para permitir que la máquina
entienda lo que hablamos, y
 Tercero , síntesis de voz para permitir que la máquina hable.
Este capítulo se enfoca en el reconocimiento del habla , el proceso de
entender las palabras que hablan los seres humanos. Recuerde que las
señales de voz se capturan con la ayuda de un micrófono y luego debe ser
entendido por el sistema.

Crear un reconocedor de voz

El reconocimiento de voz o el reconocimiento automático de voz (ASR) es el
centro de atención para proyectos de inteligencia artificial como la
robótica. Sin ASR, no es posible imaginar un robot cognitivo interactuando con
un humano. Sin embargo, no es muy fácil construir un reconocedor de voz.

Dificultades para desarrollar un sistema de reconocimiento de voz.

Desarrollar un sistema de reconocimiento de voz de alta calidad es realmente

un problema difícil. La dificultad de la tecnología de reconocimiento de voz
puede caracterizarse en términos generales a lo largo de una serie de
dimensiones como se discute a continuación
 Tamaño del vocabulario : el tamaño del vocabulario afecta la facilidad de
desarrollar un ASR. Considere los siguientes tamaños de vocabulario para una
mejor comprensión.
 o Un vocabulario de tamaño pequeño consta de 2-100 palabras, por
ejemplo, como en un sistema de menú de voz
o Un vocabulario de tamaño medio consta de varias palabras de 100 a
1,000, por ejemplo, como en una tarea de recuperación de base de datos
o Un vocabulario de gran tamaño consta de varias 10.000 palabras, como en
una tarea de dictado general.
Tenga en cuenta que cuanto mayor sea el tamaño del vocabulario, más difícil será
realizar el reconocimiento.
 Características del canal: la calidad del canal también es una dimensión
importante. Por ejemplo, el habla humana contiene un ancho de banda alto con
un rango de frecuencia completo, mientras que un discurso telefónico consiste en
un ancho de banda bajo con un rango de frecuencia limitado. Tenga en cuenta
que es más difícil en este último.
 Modo de habla : la facilidad para desarrollar un ASR también depende del modo
de hablar, es decir, si el habla está en modo de palabra aislada, o en modo de
palabra conectada, o en un modo de habla continua. Tenga en cuenta que un
discurso continuo es más difícil de reconocer.
 Estilo de expresión oral : un discurso de lectura puede ser formal o espontáneo y
conversacional con un estilo informal. Esto último es más difícil de reconocer.
 Dependencia del hablante: el habla puede depender del hablante, adaptarse al
hablante o ser independiente del hablante. Un altavoz independiente es el más
difícil de construir.
 Tipo de ruido : el ruido es otro factor a tener en cuenta al desarrollar un ASR. La
relación señal / ruido puede estar en varios rangos, dependiendo del entorno
acústico que observe menos ruido de fondo versus más ruido de fondo.
o Si la relación señal / ruido es mayor que 30dB, se considera como rango
alto
o Si la relación señal / ruido se encuentra entre 30dB y 10db, se considera
como SNR media
o Si la relación señal / ruido es inferior a 10 dB, se considera como rango
bajo
Por ejemplo, el tipo de ruido de fondo, como el ruido estacionario, no humano, el
habla de fondo y la diafonía de otros hablantes, también contribuyen a la dificultad
del problema.
 Características del micrófono : la calidad del micrófono puede ser buena, media
o inferior a la media. Además, la distancia entre la boca y el micrófono puede
variar. Estos factores también deben considerarse para los sistemas de
reconocimiento.
A pesar de estas dificultades, los investigadores trabajaron mucho en varios
aspectos del habla, como comprender la señal del habla, el hablante e
identificar los acentos.
Deberá seguir los pasos que se detallan a continuación para crear un
reconocedor de voz:

Visualización de señales de audio: lectura de un

archivo y trabajo en él
Este es el primer paso en la construcción del sistema de reconocimiento de
voz, ya que proporciona una comprensión de cómo se estructura una señal de
audio. Algunos pasos comunes que se pueden seguir para trabajar con
señales de audio son los siguientes:

Grabación

Cuando tenga que leer la señal de audio de un archivo, primero grábela con
un micrófono.

Muestreo

Al grabar con micrófono, las señales se almacenan en forma digitalizada. Pero

para trabajar en ello, la máquina los necesita en forma numérica discreta. Por
lo tanto, debemos realizar un muestreo a una frecuencia determinada y
convertir la señal a la forma numérica discreta. Elegir la frecuencia alta para el
muestreo implica que cuando los humanos escuchan la señal, la sienten como
una señal de audio continua.

Ejemplo

El siguiente ejemplo muestra un enfoque gradual para analizar una señal de

audio, utilizando Python, que se almacena en un archivo. La frecuencia de
esta señal de audio es 44.100 HZ.
Importe los paquetes necesarios como se muestra aquí:
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile

Ahora, lea el archivo de audio almacenado. Devolverá dos valores: la

frecuencia de muestreo y la señal de audio. Proporcione la ruta del archivo de
audio donde está almacenado, como se muestra aquí:
frequency_sampling, audio_signal =
wavfile.read("/Users/admin/audio_file.wav")

Visualice los parámetros como la frecuencia de muestreo de la señal de audio,

el tipo de datos de la señal y su duración, utilizando los comandos que se
muestran
print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] /
float(frequency_sampling), 2), 'seconds')
Este paso implica normalizar la señal como se muestra a continuación:
audio_signal = audio_signal / np.power(2, 15)
En este paso, estamos extrayendo los primeros 100 valores de esta señal
para visualizar. Utilice los siguientes comandos para este propósito:
audio_signal = audio_signal [:100]
time_axis = 1000 * np.arange(0, len(signal), 1) /
float(frequency_sampling)
Ahora, visualice la señal usando los comandos dados a continuación:
plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time (milliseconds)')
plt.ylabel('Amplitude')
plt.title('Input audio signal')
plt.show()

Podrá ver un gráfico de salida y datos extraídos para la señal de audio anterior
como se muestra en la imagen aquí

Signal shape: (132300,)

Signal Datatype: int16
Signal duration: 3.0 seconds

Caracterización de la señal de audio: transformación

en dominio de frecuencia
Caracterizar una señal de audio implica convertir la señal del dominio del
tiempo en dominio de frecuencia y comprender sus componentes de
frecuencia, por. Este es un paso importante porque brinda mucha información
sobre la señal. Puede usar una herramienta matemática como Transformada
de Fourier para realizar esta transformación.

Ejemplo

El siguiente ejemplo muestra, paso a paso, cómo caracterizar la señal,

utilizando Python, que se almacena en un archivo. Tenga en cuenta que aquí
estamos utilizando la herramienta matemática Transformada de Fourier para
convertirla en dominio de frecuencia.
Importe los paquetes necesarios, como se muestra aquí:
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
Ahora, lea el archivo de audio almacenado. Devolverá dos valores: la
frecuencia de muestreo y la señal de audio. Proporcione la ruta del archivo de
audio donde se almacena como se muestra en el comando aquí:
frequency_sampling, audio_signal =
wavfile.read("/Users/admin/sample.wav")
En este paso, mostraremos los parámetros como la frecuencia de muestreo de
la señal de audio, el tipo de datos de la señal y su duración, utilizando los
comandos que se proporcionan a continuación:
print('\nSignal shape:', audio_signal.shape)
print('Signal Datatype:', audio_signal.dtype)
print('Signal duration:', round(audio_signal.shape[0] /
float(frequency_sampling), 2), 'seconds')

En este paso, necesitamos normalizar la señal, como se muestra en el

siguiente comando:
audio_signal = audio_signal / np.power(2, 15)
Este paso implica extraer la longitud y la mitad de la señal. Utilice los
siguientes comandos para este propósito:
length_signal = len(audio_signal)
half_length = np.ceil((length_signal + 1) /
2.0).astype(np.int)
Ahora, necesitamos aplicar herramientas matemáticas para transformar en
dominio de frecuencia. Aquí estamos usando la Transformada de Fourier.
signal_frequency = np.fft.fft(audio_signal)
Ahora, haga la normalización de la señal del dominio de frecuencia y
cuadrátela -
signal_frequency = abs(signal_frequency[0:half_length]) /
length_signal
signal_frequency **= 2
A continuación, extraiga la longitud y la mitad de la señal transformada en
frecuencia:
len_fts = len(signal_frequency)
Tenga en cuenta que la señal transformada de Fourier debe ajustarse tanto
para casos pares como impares.
if length_signal % 2:
 signal_frequency[1:len_fts] *= 2
else:
signal_frequency[1:len_fts-1] *= 2
Ahora, extraiga la potencia en decibal (dB) -
signal_power = 10 * np.log10(signal_frequency)
Ajuste la frecuencia en kHz para el eje X -
x_axis = np.arange(0, len_half, 1) * (frequency_sampling /
length_signal) / 1000.0

Ahora, visualice la caracterización de la señal de la siguiente manera:

plt.figure()
plt.plot(x_axis, signal_power, color='black')
plt.xlabel('Frequency (kHz)')
plt.ylabel('Signal power (dB)')
plt.show()
Puede observar el gráfico de salida del código anterior como se muestra en la
imagen a continuación:

Generando señal de audio monótono

Los dos pasos que has visto hasta ahora son importantes para aprender sobre
las señales. Ahora, este paso será útil si desea generar la señal de audio con
algunos parámetros predefinidos. Tenga en cuenta que este paso guardará la
señal de audio en un archivo de salida.

Ejemplo
En el siguiente ejemplo, vamos a generar una señal monótona, usando
Python, que se almacenará en un archivo. Para esto, deberá seguir los
siguientes pasos:
Importe los paquetes necesarios como se muestra:
import numpy as np
import matplotlib.pyplot as plt
from scipy.io.wavfile import write
Proporcione el archivo donde se debe guardar el archivo de salida
output_file = 'audio_signal_generated.wav'
Ahora, especifique los parámetros de su elección, como se muestra:
duration = 4 # in seconds
frequency_sampling = 44100 # in Hz
frequency_tone = 784
min_val = -4 * np.pi
max_val = 4 * np.pi

En este paso, podemos generar la señal de audio, como se muestra:

t = np.linspace(min_val, max_val, duration *
frequency_sampling)
audio_signal = np.sin(2 * np.pi * tone_freq * t)

Ahora, guarde el archivo de audio en el archivo de salida -

write(output_file, frequency_sampling, signal_scaled)
Extraiga los primeros 100 valores para nuestro gráfico, como se muestra:
audio_signal = audio_signal[:100]
time_axis = 1000 * np.arange(0, len(signal), 1) /
float(sampling_freq)
Ahora, visualice la señal de audio generada de la siguiente manera:
plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time in milliseconds')
plt.ylabel('Amplitude')
plt.title('Generated audio signal')
plt.show()
Puede observar la trama como se muestra en la figura dada aquí:
Extracción de funciones del discurso
Este es el paso más importante para construir un reconocedor de voz porque
después de convertir la señal de voz en el dominio de frecuencia, debemos
convertirla en la forma utilizable del vector de características. Podemos utilizar
diferentes técnicas de extracción de características como MFCC, PLP, PLP-
RASTA, etc. para este propósito.

Ejemplo

En el siguiente ejemplo, vamos a extraer las características de la señal, paso a

paso, usando Python, usando la técnica MFCC.
Importe los paquetes necesarios, como se muestra aquí:
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from python_speech_features import mfcc, logfbank

Ahora, lea el archivo de audio almacenado. Devolverá dos valores: la

frecuencia de muestreo y la señal de audio. Proporcione la ruta del archivo de
audio donde está almacenado.
frequency_sampling, audio_signal =
wavfile.read("/Users/admin/audio_file.wav")

Tenga en cuenta que aquí estamos tomando las primeras 15000 muestras
para su análisis.
audio_signal = audio_signal[:15000]
Use las técnicas de MFCC y ejecute el siguiente comando para extraer las
características de MFCC:
features_mfcc = mfcc(audio_signal, frequency_sampling)
Ahora, imprima los parámetros MFCC, como se muestra:
print('\nMFCC:\nNumber of windows =', features_mfcc.shape[0])
print('Length of each feature =', features_mfcc.shape[1])
Ahora, trace y visualice las características de MFCC utilizando los comandos
que se proporcionan a continuación:
features_mfcc = features_mfcc.T
plt.matshow(features_mfcc)
plt.title('MFCC')

En este paso, trabajamos con las características del banco de filtros como se
muestra:
Extraiga las características del banco de filtros:
filterbank_features = logfbank(audio_signal,
frequency_sampling)
Ahora, imprima los parámetros del banco de filtros.
print('\nFilter bank:\nNumber of windows =',
filterbank_features.shape[0])
print('Length of each feature =',
filterbank_features.shape[1])

Ahora, trace y visualice las características del banco de filtros.

filterbank_features = filterbank_features.T
plt.matshow(filterbank_features)
plt.title('Filter bank')
plt.show()
Como resultado de los pasos anteriores, puede observar los siguientes
resultados: Figura 1 para MFCC y Figura 2 para Banco de filtros
Reconocimiento de palabras habladas
El reconocimiento de voz significa que cuando los humanos están hablando,
una máquina lo entiende. Aquí estamos utilizando la API de Google Speech en
Python para que esto suceda. Necesitamos instalar los siguientes paquetes
para esto:
 Pyaudio : se puede instalar mediante el comando pip install Pyaudio .
 SpeechRecognition - Este paquete se puede instalar mediante el uso de pepita
instalar SpeechRecognition.
 Google-Speech-API : se puede instalar mediante el comando pip install google-
api-python-client .

Ejemplo

Observe el siguiente ejemplo para comprender el reconocimiento de palabras

habladas:
Importe los paquetes necesarios como se muestra:
import speech_recognition as sr
Cree un objeto como se muestra a continuación:
recording = sr.Recognizer()
Ahora, el módulo Micrófono () tomará la voz como entrada:
with sr.Microphone() as source:
recording.adjust_for_ambient_noise(source)
print("Please Say something:")
 audio = recording.listen(source)
Ahora google API reconocería la voz y da la salida.
try:
print("You said: \n" + recording.recognize_google(audio))
except Exception as e:
print(e)
Puedes ver el siguiente resultado:
Please Say Something:
You said:
Por ejemplo, si dijo postparaprogramadores.com , el sistema lo reconoce
correctamente de la siguiente manera:
postparaprogramadores.com

AI con Python - Búsqueda heurística

La búsqueda heurística desempeña un papel clave en la inteligencia
artificial. En este capítulo, aprenderá en detalle al respecto.

Concepto de búsqueda heurística en IA

La heurística es una regla general que nos lleva a la solución probable. La
mayoría de los problemas en inteligencia artificial son de naturaleza
exponencial y tienen muchas soluciones posibles. No sabe exactamente qué
soluciones son correctas y verificar todas las soluciones sería muy costoso.
Por lo tanto, el uso de la heurística reduce la búsqueda de solución y elimina
las opciones incorrectas. El método de usar la heurística para dirigir la
búsqueda en el espacio de búsqueda se llama Búsqueda heurística. Las
técnicas heurísticas son muy útiles porque la búsqueda se puede aumentar
cuando las usas.

Diferencia entre búsqueda desinformada e informada

Hay dos tipos de estrategias de control o técnicas de búsqueda:
desinformadas e informadas. Se explican en detalle como se da aquí:

Búsqueda desinformada

También se llama búsqueda ciega o estrategia de control ciego. Se llama así

porque solo hay información sobre la definición del problema y no hay otra
información adicional disponible sobre los estados. Este tipo de técnicas de
búsqueda buscaría en todo el espacio de estado para obtener la
solución. Breadth First Search (BFS) y Depth First Search (DFS) son ejemplos
de búsqueda no informada.

Búsqueda informada
También se llama búsqueda heurística o estrategia de control heurístico. Se
llama así porque hay información adicional sobre los estados. Esta
información adicional es útil para calcular la preferencia entre los nodos
secundarios para explorar y expandirse. Habría una función heurística
asociada con cada nodo. Best First Search (BFS), A *, Mean and Analysis son
ejemplos de búsqueda informada.

Problemas de satisfacción de restricciones (CSP)

Restricción significa restricción o limitación. En IA, los problemas de

satisfacción de restricciones son los problemas que deben resolverse bajo
algunas restricciones. El foco debe estar en no violar la restricción al resolver
tales problemas. Finalmente, cuando llegamos a la solución final, CSP debe
obedecer la restricción.

Problema del mundo real resuelto por satisfacción de

restricciones
Las secciones anteriores trataban de crear problemas de satisfacción de
restricciones. Ahora, apliquemos esto también a los problemas del mundo
real. Algunos ejemplos de problemas del mundo real resueltos por la
satisfacción de restricciones son los siguientes:

Resolviendo la relación algebraica

Con la ayuda del problema de satisfacción de restricciones, podemos resolver

las relaciones algebraicas. En este ejemplo, intentaremos resolver una
relación algebraica simple a * 2 = b . Devolverá el valor de a y b dentro del
rango que definiríamos.
Después de completar este programa de Python, podrá comprender los
conceptos básicos para resolver problemas con satisfacción de restricciones.
Tenga en cuenta que antes de escribir el programa, necesitamos instalar el
paquete Python llamado restricción de python. Puede instalarlo con la ayuda
del siguiente comando:
pip install python-constraint
Los siguientes pasos le muestran un programa de Python para resolver
relaciones algebraicas utilizando la satisfacción de restricciones:
Importe el paquete de restricciones con el siguiente comando:
from constraint import *
Ahora, cree un objeto de módulo llamado problem () como se muestra a
continuación:
problem = Problem()
Ahora, defina variables. Tenga en cuenta que aquí tenemos dos variables a y
b, y estamos definiendo 10 como su rango, lo que significa que obtuvimos la
solución dentro de los primeros 10 números.
problem.addVariable('a', range(10))
problem.addVariable('b', range(10))
A continuación, defina la restricción particular que queremos aplicar a este
problema. Observe que aquí estamos usando la restricción a * 2 = b .
problem.addConstraint(lambda a, b: a * 2 == b)
Ahora, cree el objeto del módulo getSolution () usando el siguiente comando:
solutions = problem.getSolutions()
Por último, imprima la salida con el siguiente comando:
print (solutions)
Puede observar la salida del programa anterior de la siguiente manera:
[{'a': 4, 'b': 8}, {'a': 3, 'b': 6}, {'a': 2, 'b': 4}, {'a':
1, 'b': 2}, {'a': 0, 'b': 0}]

Cuadrado mágico

Un cuadrado mágico es una disposición de números distintos, generalmente

enteros, en una cuadrícula cuadrada, donde los números en cada fila y en
cada columna, y los números en diagonal, se suman al mismo número
llamado "constante mágica" .
La siguiente es una ejecución gradual del código simple de Python para
generar cuadrados mágicos:
Defina una función llamada magic_square , como se muestra a continuación:
def magic_square(matrix_ms):
iSize = len(matrix_ms[0])
sum_list = []
El siguiente código muestra el código para vertical de cuadrados:
for col in range(iSize):
sum_list.append(sum(row[col] for row in matrix_ms))
El siguiente código muestra el código para horizontales de cuadrados:
sum_list.extend([sum (lines) for lines in matrix_ms])
El siguiente código muestra el código para horizontal de cuadrados:
dlResult = 0
for i in range(0,iSize):
dlResult +=matrix_ms[i][i]
sum_list.append(dlResult)
drResult = 0
for i in range(iSize-1,-1,-1):
 drResult +=matrix_ms[i][i]
sum_list.append(drResult)

if len(set(sum_list))>1:
return False
return True
Ahora, proporcione el valor de la matriz y verifique la salida:
print(magic_square([[1,2,3], [4,5,6], [7,8,9]]))
Puede observar que la salida sería Falsa ya que la suma no es igual al mismo
número.
print(magic_square([[3,9,2], [3,5,7], [9,1,6]]))
Puede observar que la salida sería True ya que la suma es el mismo número,
es decir, 15 aquí.

AI con Python - Juegos

Los juegos se juegan con una estrategia. Cada jugador o equipo haría una
estrategia antes de comenzar el juego y tienen que cambiar o construir una
nueva estrategia de acuerdo con la situación actual del juego.

Algoritmos de búsqueda
Tendrás que considerar los juegos de computadora también con la misma
estrategia que la anterior. Tenga en cuenta que los algoritmos de búsqueda
son los que determinan la estrategia en los juegos de computadora.

Cómo funciona

El objetivo de los algoritmos de búsqueda es encontrar el conjunto óptimo de

movimientos para que puedan llegar al destino final y ganar. Estos algoritmos
utilizan el conjunto ganador de condiciones, diferentes para cada juego, para
encontrar los mejores movimientos.
Visualiza un juego de computadora como el árbol. Sabemos que el árbol tiene
nodos. Comenzando desde la raíz, podemos llegar al nodo ganador final, pero
con movimientos óptimos. Ese es el trabajo de los algoritmos de
búsqueda. Cada nodo en dicho árbol representa un estado futuro. Los
algoritmos de búsqueda buscan en este árbol para tomar decisiones en cada
paso o nodo del juego.

Búsqueda combinacional
La principal desventaja de usar algoritmos de búsqueda es que son de
naturaleza exhaustiva, por lo que exploran todo el espacio de búsqueda para
encontrar la solución que conduce al desperdicio de recursos. Sería más
engorroso si estos algoritmos necesitan buscar en todo el espacio de
búsqueda para encontrar la solución final.
Para eliminar este tipo de problema, podemos usar la búsqueda
combinacional que usa la heurística para explorar el espacio de búsqueda y
reduce su tamaño al eliminar los posibles movimientos incorrectos. Por lo
tanto, tales algoritmos pueden ahorrar los recursos. Aquí se analizan algunos
de los algoritmos que usan la heurística para buscar en el espacio y guardar
los recursos:

Algoritmo Minimax
Es la estrategia utilizada por la búsqueda combinacional que utiliza la
heurística para acelerar la estrategia de búsqueda. El concepto de estrategia
Minimax puede entenderse con el ejemplo de juegos de dos jugadores, en los
que cada jugador intenta predecir el próximo movimiento del oponente y trata
de minimizar esa función. Además, para ganar, el jugador siempre intenta
maximizar su propia función en función de la situación actual.
La heurística juega un papel importante en este tipo de estrategias como
Minimax. Cada nodo del árbol tendría una función heurística asociada a él. En
base a esa heurística, tomará la decisión de avanzar hacia el nodo que más
los beneficiaría.

Poda Alfa-Beta
Un problema importante con el algoritmo Minimax es que puede explorar
aquellas partes del árbol que son irrelevantes, lo que lleva al desperdicio de
recursos. Por lo tanto, debe haber una estrategia para decidir qué parte del
árbol es relevante y cuál es irrelevante y dejar la parte irrelevante sin
explorar. La poda alfa-beta es uno de esos tipos de estrategia.
El objetivo principal del algoritmo de poda Alpha-Beta es evitar la búsqueda de
aquellas partes del árbol que no tienen ninguna solución. El concepto principal
de la poda Alpha-Beta es utilizar dos límites llamados Alpha , el límite inferior
máximo y Beta , el límite superior mínimo. Estos dos parámetros son los
valores que restringen el conjunto de posibles soluciones. Compara el valor
del nodo actual con el valor de los parámetros alfa y beta, para que pueda
moverse a la parte del árbol que tiene la solución y descartar el resto.

Algoritmo Negamax
Este algoritmo no es diferente del algoritmo Minimax, pero tiene una
implementación más elegante. La principal desventaja de usar el algoritmo
Minimax es que necesitamos definir dos funciones heurísticas diferentes. La
conexión entre estos heurísticos es que, cuanto mejor es el estado de un
juego para un jugador, peor es para el otro jugador. En el algoritmo Negamax,
el mismo trabajo de dos funciones heurísticas se realiza con la ayuda de una
única función heurística.

Construyendo bots para jugar juegos

Para construir bots para jugar juegos de dos jugadores en IA, necesitamos
instalar la biblioteca easyAI . Es un marco de inteligencia artificial que
proporciona toda la funcionalidad para construir juegos de dos
jugadores. Puede descargarlo con la ayuda del siguiente comando:
pip install easyAI

Un bot para jugar la última moneda en pie

En este juego, habría un montón de monedas. Cada jugador tiene que tomar
una cantidad de monedas de esa pila. El objetivo del juego es evitar tomar la
última moneda del montón. Utilizaremos la clase LastCoinStanding heredada
de la clase TwoPlayersGame de la biblioteca easyAI . El siguiente código
muestra el código de Python para este juego:
Importe los paquetes necesarios como se muestra:
from easyAI import TwoPlayersGame, id_solve, Human_Player,
AI_Player
from easyAI.AI import TT
Ahora, herede la clase de la clase TwoPlayerGame para manejar todas las
operaciones del juego:
class LastCoin_game(TwoPlayersGame):
def __init__(self, players):

Ahora, defina los jugadores y el jugador que va a comenzar el juego.

self.players = players
self.nplayer = 1

Ahora, defina el número de monedas en el juego, aquí estamos usando 15

monedas para el juego.
self.num_coins = 15
Define el número máximo de monedas que un jugador puede tomar en un
movimiento.
self.max_coins = 4
Ahora hay ciertas cosas para definir como se muestra en el siguiente
código. Definir posibles movimientos.
def possible_moves(self):
return [str(a) for a in range(1, self.max_coins + 1)]

Definir la retirada de las monedas.

def make_move(self, move):
self.num_coins -= int(move)

Define quién tomó la última moneda.

def win_game(self):
 return self.num_coins <= 0
Define cuándo detener el juego, es decir, cuando alguien gana.
def is_over(self):
return self.win()
Defina cómo calcular la puntuación.
def score(self):
return 100 if self.win_game() else 0
Defina el número de monedas restantes en la pila.
def show(self):
print(self.num_coins, 'coins left in the pile')
if __name__ == "__main__":
tt = TT()
LastCoin_game.ttentry = lambda self: self.num_coins

Resolviendo el juego con el siguiente bloque de código:

r, d, m = id_solve(LastCoin_game,
range(2, 20), win_score=100, tt=tt)
print(r, d, m)
Decidir quién comenzará el juego
game = LastCoin_game([AI_Player(tt), Human_Player()])
game.play()
Puedes encontrar el siguiente resultado y un juego simple de este juego:
d:2, a:0, m:1
d:3, a:0, m:1
d:4, a:0, m:1
d:5, a:0, m:1
d:6, a:100, m:4
1 6 4
15 coins left in the pile
Move #1: player 1 plays 4 :
11 coins left in the pile
Player 2 what do you play ? 2
Move #2: player 2 plays 2 :
9 coins left in the pile
Move #3: player 1 plays 3 :
6 coins left in the pile
Player 2 what do you play ? 1
Move #4: player 2 plays 1 :
5 coins left in the pile
Move #5: player 1 plays 4 :
1 coins left in the pile
Player 2 what do you play ? 1
Move #6: player 2 plays 1 :
0 coins left in the pile
Un bot para jugar tres en raya
Tic-Tac-Toe es muy familiar y uno de los juegos más
populares. Creemos este juego usando la biblioteca easyAI en Python. El
siguiente código es el código Python de este juego:
Importe los paquetes como se muestra:
from easyAI import TwoPlayersGame, AI_Player, Negamax
from easyAI.Player import Human_Player
Herede la clase de la clase TwoPlayerGame para manejar todas las
operaciones del juego:
class TicTacToe_game(TwoPlayersGame):
def __init__(self, players):
Ahora, defina los jugadores y el jugador que va a comenzar el juego.
self.players = players
self.nplayer = 1
Definir el tipo de tablero -
self.board = [0] * 9
Ahora hay algunas cosas ciertas para definir de la siguiente manera:
Define posibles movimientos
def possible_moves(self):
return [x + 1 for x, y in enumerate(self.board) if y == 0]
Define el movimiento de un jugador:
def make_move(self, move):
self.board[int(move) - 1] = self.nplayer
Para aumentar la IA, define cuándo un jugador hace un movimiento:
def umake_move(self, move):
self.board[int(move) - 1] = 0
Define la condición de pérdida de que un oponente tiene tres en línea
def condition_for_lose(self):
possible_combinations = [[1,2,3], [4,5,6], [7,8,9],
[1,4,7], [2,5,8], [3,6,9], [1,5,9], [3,5,7]]
return any([all([(self.board[z-1] == self.nopponent)
for z in combination]) for combination in
possible_combinations])
Definir un cheque para el final del juego.
def is_over(self):
return (self.possible_moves() == []) or
self.condition_for_lose()
Muestra la posición actual de los jugadores en el juego.
def show(self):
print('\n'+'\n'.join([' '.join([['.', 'O',
'X'][self.board[3*j + i]]
for i in range(3)]) for j in range(3)]))
Calcule los puntajes.
def scoring(self):
return -100 if self.condition_for_lose() else 0

Defina el método principal para definir el algoritmo e iniciar el juego.

if __name__ == "__main__":
algo = Negamax(7)
TicTacToe_game([Human_Player(), AI_Player(algo)]).play()
Puedes ver el siguiente resultado y un juego simple de este juego:
. . .
. . .
. . .
Player 1 what do you play ? 1
Move #1: player 1 plays 1 :
O . .
. . .
. . .
Move #2: player 2 plays 5 :
O . .
. X .
121
. . .
Player 1 what do you play ? 3
Move #3: player 1 plays 3 :
O . O
. X .
. . .
Move #4: player 2 plays 2 :
O X O
. X .
. . .
Player 1 what do you play ? 4
Move #5: player 1 plays 4 :
O X O
O X .
. . .
Move #6: player 2 plays 8 :
O X O
O X .
. X .
AI con Python - Redes neuronales
Las redes neuronales son dispositivos informáticos paralelos que intentan
hacer un modelo informático del cerebro. El objetivo principal detrás es
desarrollar un sistema para realizar varias tareas computacionales más rápido
que los sistemas tradicionales. Estas tareas incluyen reconocimiento y
clasificación de patrones, aproximación, optimización y agrupación de datos.

¿Qué son las redes neuronales artificiales (ANN)?

La red neuronal artificial (ANN) es un sistema informático eficiente cuyo tema
central está tomado de la analogía de las redes neuronales biológicas. Los
ANN también se denominan sistemas neuronales artificiales, sistemas de
procesamiento distribuido en paralelo y sistemas conexionistas. ANN adquiere
una gran colección de unidades que están interconectadas en algún patrón
para permitir las comunicaciones entre ellas. Estas unidades, también
conocidas como nodos o neuronas , son procesadores simples que
funcionan en paralelo.
Cada neurona está conectada con otra neurona a través de un enlace de
conexión . Cada enlace de conexión está asociado con un peso que tiene la
información sobre la señal de entrada. Esta es la información más útil para
que las neuronas resuelvan un problema particular porque
el peso generalmente excita o inhibe la señal que se está comunicando. Cada
neurona tiene su estado interno que se llama señal de activación . Las
señales de salida, que se producen después de combinar las señales de
entrada y la regla de activación, pueden enviarse a otras unidades.
Si desea estudiar las redes neuronales en detalle, puede seguir el enlace -
Red neuronal artificial .

Instalar paquetes útiles

Para crear redes neuronales en Python, podemos usar un paquete poderoso
para redes neuronales llamado NeuroLab . Es una biblioteca de algoritmos
básicos de redes neuronales con configuraciones de red flexibles y algoritmos
de aprendizaje para Python. Puede instalar este paquete con la ayuda del
siguiente comando en el símbolo del sistema:
pip install NeuroLab
Si está utilizando el entorno Anaconda, utilice el siguiente comando para
instalar NeuroLab:
conda install -c labfabulous neurolab

Construyendo redes neuronales

En esta sección, construyamos algunas redes neuronales en Python usando el
paquete NeuroLab.

Clasificador basado en Perceptron

Los perceptrones son los bloques de construcción de ANN. Si desea saber
más sobre Perceptron, puede seguir el enlace - artificial_neural_network
A continuación se muestra una ejecución gradual del código de Python para
construir un clasificador basado en perceptrón de red neuronal simple:
Importe los paquetes necesarios como se muestra:
import matplotlib.pyplot as plt
import neurolab as nl
Ingrese los valores de entrada. Tenga en cuenta que es un ejemplo de
aprendizaje supervisado, por lo tanto, también deberá proporcionar valores
objetivo.
input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]
Cree la red con 2 entradas y 1 neurona:
net = nl.net.newp([[0, 1],[0, 1]], 1)
Ahora, entrena la red. Aquí, estamos usando la regla Delta para el
entrenamiento.
error_progress = net.train(input, target, epochs=100,
show=10, lr=0.1)
Ahora, visualice el resultado y trace el gráfico -
plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()
Puede ver el siguiente gráfico que muestra el progreso del entrenamiento
utilizando la métrica de error:
Redes neuronales de una sola capa
En este ejemplo, estamos creando una red neuronal de capa única que
consiste en neuronas independientes que actúan sobre los datos de entrada
para producir la salida. Tenga en cuenta que estamos utilizando el archivo de
texto llamado neural_simple.txt como nuestra entrada.
Importe los paquetes útiles como se muestra:
import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl
Cargue el conjunto de datos de la siguiente manera:
input_data = np.loadtxt(“/Users/admin/neural_simple.txt')
Los siguientes son los datos que vamos a utilizar. Tenga en cuenta que en
estos datos, las dos primeras columnas son las características y las dos
últimas columnas son las etiquetas.
array([[2. , 4. , 0. , 0. ],
[1.5, 3.9, 0. , 0. ],
[2.2, 4.1, 0. , 0. ],
[1.9, 4.7, 0. , 0. ],
[5.4, 2.2, 0. , 1. ],
[4.3, 7.1, 0. , 1. ],
[5.8, 4.9, 0. , 1. ],
[6.5, 3.2, 0. , 1. ],
[3. , 2. , 1. , 0. ],
[2.5, 0.5, 1. , 0. ],
[3.5, 2.1, 1. , 0. ],
[2.9, 0.3, 1. , 0. ],
[6.5, 8.3, 1. , 1. ],
[3.2, 6.2, 1. , 1. ],
[4.9, 7.8, 1. , 1. ],
[2.1, 4.8, 1. , 1. ]])

Ahora, separe estas cuatro columnas en 2 columnas de datos y 2 etiquetas:

data = input_data[:, 0:2]
labels = input_data[:, 2:]

Trace los datos de entrada usando los siguientes comandos:

plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')
Ahora, defina los valores mínimo y máximo para cada dimensión como se
muestra aquí:
dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()
A continuación, defina el número de neuronas en la capa de salida de la
siguiente manera:
nn_output_layer = labels.shape[1]
Ahora, defina una red neuronal de capa única:
dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)
Entrene la red neuronal con el número de épocas y la tasa de aprendizaje
como se muestra:
error = neural_net.train(data, labels, epochs = 200, show =
20, lr = 0.01)

Ahora, visualice y trace el progreso del entrenamiento con los siguientes

comandos:
plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()
Ahora, use los puntos de datos de prueba en el clasificador anterior:
print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]]
for item in data_test:
print(item, '-->', neural_net.sim([item])[0])

Puede encontrar los resultados de la prueba como se muestra aquí:

[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]

Puede ver los siguientes gráficos como la salida del código discutido hasta
ahora:
Redes neuronales multicapa
En este ejemplo, estamos creando una red neuronal multicapa que consta de
más de una capa para extraer los patrones subyacentes en los datos de
entrenamiento. Esta red neuronal multicapa funcionará como un
regresor. Vamos a generar algunos puntos de datos basados en la ecuación: y
= 2x 2 +8.
Importe los paquetes necesarios como se muestra:
import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Genere algún punto de datos basado en la ecuación mencionada

anteriormente:
min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)

Ahora, cambie la forma de este conjunto de datos de la siguiente manera:

data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)
Visualice y trace el conjunto de datos de entrada utilizando los siguientes
comandos:
plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')
Ahora, construya la red neuronal con dos capas ocultas
con neurolab con diez neuronas en la primera capa oculta, seis en la
segunda capa oculta y una en la capa de salida.
neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])
Ahora usa el algoritmo de entrenamiento de gradiente -
neural_net.trainf = nl.train.train_gd
Ahora capacite a la red con el objetivo de aprender sobre los datos generados
anteriormente:
error = neural_net.train(data, labels, epochs = 1000, show =
100, goal = 0.01)

Ahora, ejecute las redes neuronales en los puntos de datos de entrenamiento:

output = neural_net.sim(data)
y_pred = output.reshape(num_points)

Ahora tarea de trazado y visualización -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')
Ahora trazaremos el resultado real versus el pronosticado:
x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred =
neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_den
se.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred,
'p')
plt.title('Actual vs predicted')
plt.show()
Como resultado de los comandos anteriores, puede observar los gráficos
como se muestra a continuación:
 AI con Python - Aprendizaje de refuerzo
En este capítulo, aprenderá en detalle sobre el aprendizaje de refuerzo de
conceptos en IA con Python.

Conceptos básicos del aprendizaje por refuerzo

Este tipo de aprendizaje se utiliza para reforzar o fortalecer la red basada en
información crítica. Es decir, una red que se está capacitando bajo aprendizaje
de refuerzo, recibe algunos comentarios del entorno. Sin embargo, la
retroalimentación es evaluativa y no instructiva como en el caso del
aprendizaje supervisado. Con base en estos comentarios, la red realiza los
ajustes de los pesos para obtener una mejor información crítica en el futuro.
Este proceso de aprendizaje es similar al aprendizaje supervisado, pero
podríamos tener muy poca información. La siguiente figura muestra el
diagrama de bloques del aprendizaje por refuerzo:

Bloques de construcción: medio ambiente y agente

El entorno y el agente son los principales componentes del aprendizaje por
refuerzo en IA. Esta sección los analiza en detalle:

Agente

Un agente es cualquier cosa que puede percibir su entorno a través de

sensores y actúa sobre ese entorno a través de efectores.
 Un agente humano tiene órganos sensoriales como ojos, oídos, nariz, lengua y
piel paralelos a los sensores, y otros órganos como manos, piernas, boca, para
efectores.
 Un agente robótico reemplaza cámaras y buscadores de rango infrarrojo para los
sensores, y varios motores y actuadores para efectores.
 Un agente de software ha codificado cadenas de bits como sus programas y
acciones.

Terminología del agente

Los siguientes términos se usan con más frecuencia en el aprendizaje por

refuerzo en IA:
 Medida de rendimiento del agente : es el criterio que determina el éxito de un
agente.
 Comportamiento del agente : es la acción que realiza el agente después de
cualquier secuencia de percepciones.
 Percepción : son las entradas perceptivas del agente en una instancia
determinada.
  Percepción de secuencia : es la historia de todo lo que un agente ha percibido
hasta la fecha.
 Función del agente : es un mapa de la secuencia de preceptos a una acción.

Ambiente

Algunos programas operan en un entorno completamente artificial limitado a

la entrada del teclado, la base de datos, los sistemas de archivos de
computadora y la salida de caracteres en una pantalla.
Por el contrario, algunos agentes de software, como robots de software o
softbots, existen en dominios de softbot ricos e ilimitados. El simulador tiene
un entorno muy detallado y complejo . El agente de software debe elegir
entre una gran variedad de acciones en tiempo real.
Por ejemplo, un softbot diseñado para escanear las preferencias en línea del
cliente y mostrar elementos interesantes para el cliente funciona tanto
en un entorno real como artificial .

Propiedades del medio ambiente

El entorno tiene propiedades múltiples como se analiza a continuación:

 Discreto / continuo : si hay un número limitado de estados del entorno distintos,
claramente definidos, el entorno es discreto, de lo contrario es continuo. Por
ejemplo, el ajedrez es un entorno discreto y la conducción es un entorno continuo.
 Observable / parcialmente observable : si es posible determinar el estado
completo del entorno en cada punto de tiempo desde las percepciones, es
observable; de lo contrario, solo es parcialmente observable.
 Estático / Dinámico : si el entorno no cambia mientras un agente está actuando,
entonces es estático; de lo contrario es dinámico.
 Agente único / agentes múltiples : el entorno puede contener otros agentes que
pueden ser del mismo tipo o de un tipo diferente al del agente.
 Accesible / Inaccesible : si el aparato sensorial del agente puede tener acceso al
estado completo del entorno, el agente puede acceder al entorno; de lo contrario
es inaccesible.
 Determinista / no determinista : si el siguiente estado del entorno está
completamente determinado por el estado actual y las acciones del agente,
entonces el entorno es determinista; de lo contrario no es determinista.
 Episódico / No episódico : en un entorno episódico, cada episodio consiste en
que el agente perciba y luego actúe. La calidad de su acción depende solo del
episodio en sí. Los episodios posteriores no dependen de las acciones en los
episodios anteriores. Los entornos episódicos son mucho más simples porque el
agente no necesita pensar en el futuro.
Construyendo un entorno con Python
Para construir un agente de aprendizaje de refuerzo, usaremos
el paquete OpenAI Gym que se puede instalar con la ayuda del siguiente
comando:
pip install gym
Hay varios entornos en el gimnasio OpenAI que se pueden utilizar para
diversos fines. Pocos de ellos son Cartpole-v0, Hopper-v1 y MsPacman-
v0 . Requieren diferentes motores. La documentación detallada de OpenAI
Gym se puede encontrar en https://gym.openai.com/docs/#environments .
El siguiente código muestra un ejemplo de código Python para el entorno
cartpole-v0:
import gym
env = gym.make('CartPole-v0')
env.reset()
for _ in range(1000):
env.render()
env.step(env.action_space.sample())

Puede construir otros entornos de manera similar.

Construyendo un agente de aprendizaje con Python

Para construir un agente de aprendizaje de refuerzo, usaremos
el paquete OpenAI Gym como se muestra:
import gym
env = gym.make('CartPole-v0')
for _ in range(20):
observation = env.reset()
for i in range(100):
env.render()
print(observation)
action = env.action_space.sample()
observation, reward, done, info = env.step(action)
if done:
print("Episode finished after {}
timesteps".format(i+1))
break

Observe que la carreta puede equilibrarse.

AI con Python - Algoritmos genéticos

Este capítulo analiza los algoritmos genéticos de la IA en detalle.

¿Qué son los algoritmos genéticos?

Los algoritmos genéticos (GA) son algoritmos basados en búsquedas basados
en los conceptos de selección natural y genética. Los GA son un subconjunto
de una rama de cómputo mucho más grande conocida como cómputo
evolutivo.
Los GA fueron desarrollados por John Holland y sus estudiantes y colegas de
la Universidad de Michigan, especialmente David E. Goldberg. Desde
entonces se ha probado en varios problemas de optimización con un alto
grado de éxito.
En GA, tenemos un conjunto de posibles soluciones para el problema
dado. Estas soluciones se someten a recombinación y mutación (como en la
genética natural), produce nuevos hijos y el proceso se repite durante varias
generaciones. A cada individuo (o solución candidata) se le asigna un valor de
aptitud (basado en su valor de función objetivo) y los individuos más en forma
tienen una mayor oportunidad de aparearse y producir individuos más
en forma . Esto está en línea con la teoría darwiniana de la supervivencia del
más apto .
Por lo tanto, sigue evolucionando mejores individuos o soluciones durante
generaciones, hasta que alcanza un criterio de detención.
Los algoritmos genéticos tienen una naturaleza suficientemente aleatoria, pero
funcionan mucho mejor que la búsqueda local aleatoria (donde solo
intentamos soluciones aleatorias, haciendo un seguimiento de los mejores
hasta ahora), ya que también explotan la información histórica.

¿Cómo usar GA para problemas de optimización?

La optimización es una acción para hacer que el diseño, la situación, los
recursos y el sistema sean lo más efectivos posible. El siguiente diagrama de
bloques muestra el proceso de optimización:

Etapas del mecanismo de GA para el proceso de optimización

La siguiente es una secuencia de pasos del mecanismo GA cuando se usa

para la optimización de problemas.
 Paso 1 - Genera la población inicial al azar.
 Paso 2: seleccione la solución inicial con los mejores valores de condición física.
 Paso 3 - Recombine las soluciones seleccionadas usando operadores de
mutación y cruce.
 Paso 4: inserte una descendencia en la población.
 Paso 5: ahora, si se cumple la condición de detención, devuelva la solución con su
mejor valor de condición física. De lo contrario, vaya al paso 2.

Instalar paquetes necesarios

Para resolver el problema mediante el uso de algoritmos genéticos en Python,
vamos a utilizar un poderoso paquete para GA llamado DEAP . Es una
biblioteca de novedoso marco de cálculo evolutivo para la creación rápida de
prototipos y pruebas de ideas. Podemos instalar este paquete con la ayuda del
siguiente comando en el símbolo del sistema:
pip install deap
Si está utilizando un entorno anaconda , el siguiente comando se puede
utilizar para instalar deap:
conda install -c conda-forge deap
Implementando soluciones usando algoritmos
genéticos
Esta sección le explica la implementación de soluciones utilizando algoritmos
genéticos.

Generando patrones de bits

El siguiente ejemplo muestra cómo generar una cadena de bits que contendría
15 unidades, según el problema de One Max .
Importe los paquetes necesarios como se muestra:
import random
from deap import base, creator, tools

Definir la función de evaluación. Es el primer paso para crear un algoritmo

genético.
def eval_func(individual):
target_sum = 15
return len(individual) - abs(sum(individual) -
target_sum),

Ahora, cree la caja de herramientas con los parámetros correctos:

def create_toolbox(num_bits):
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list,
fitness=creator.FitnessMax)

Inicializar la caja de herramientas

toolbox = base.Toolbox()
toolbox.register("attr_bool", random.randint, 0, 1)
toolbox.register("individual", tools.initRepeat,
creator.Individual,
toolbox.attr_bool, num_bits)
toolbox.register("population", tools.initRepeat, list,
toolbox.individual)
Registre el operador de evaluación -
toolbox.register("evaluate", eval_func)
Ahora, registre el operador cruzado -
toolbox.register("mate", tools.cxTwoPoint)
Registrar un operador de mutación -
toolbox.register("mutate", tools.mutFlipBit, indpb = 0.05)

Definir el operador para la cría -

toolbox.register("select", tools.selTournament, tournsize =
3)
return toolbox
if __name__ == "__main__":
num_bits = 45
toolbox = create_toolbox(num_bits)
random.seed(7)
population = toolbox.population(n = 500)
probab_crossing, probab_mutating = 0.5, 0.2
num_generations = 10
print('\nEvolution process starts')

Evaluar a toda la población

fitnesses = list(map(toolbox.evaluate, population))
for ind, fit in zip(population, fitnesses):
ind.fitness.values = fit
print('\nEvaluated', len(population), 'individuals')

Crea e itera de generación en generación.

for g in range(num_generations):
print("\n- Generation", g)

Selección de las personas de la próxima generación:

offspring = toolbox.select(population, len(population))
Ahora, clone a los individuos seleccionados:
offspring = list(map(toolbox.clone, offspring))
Aplicar crossover y mutación en la descendencia -
for child1, child2 in zip(offspring[::2], offspring[1::2]):
if random.random() < probab_crossing:
toolbox.mate(child1, child2)
Eliminar el valor de aptitud del niño
del child1.fitness.values
del child2.fitness.values
Ahora, aplique la mutación -
for mutant in offspring:
if random.random() < probab_mutating:
toolbox.mutate(mutant)
del mutant.fitness.values

Evaluar a las personas con una aptitud no válida:

invalid_ind = [ind for ind in offspring if not
ind.fitness.valid]
fitnesses = map(toolbox.evaluate, invalid_ind)
for ind, fit in zip(invalid_ind, fitnesses):
ind.fitness.values = fit
print('Evaluated', len(invalid_ind), 'individuals')
Ahora, reemplace la población con la próxima generación individual
population[:] = offspring
Imprima las estadísticas para las generaciones actuales -
fits = [ind.fitness.values[0] for ind in population]
length = len(population)
mean = sum(fits) / length
sum2 = sum(x*x for x in fits)
std = abs(sum2 / length - mean**2)**0.5
print('Min =', min(fits), ', Max =', max(fits))
print('Average =', round(mean, 2), ', Standard deviation =',
round(std, 2))
print("\n- Evolution ends")
Imprima el resultado final -
best_ind = tools.selBest(population, 1)[0]
print('\nBest individual:\n', best_ind)
print('\nNumber of ones:', sum(best_ind))
Following would be the output:
Evolution process starts
Evaluated 500 individuals
- Generation 0
Evaluated 295 individuals
Min = 32.0 , Max = 45.0
Average = 40.29 , Standard deviation = 2.61
- Generation 1
Evaluated 292 individuals
Min = 34.0 , Max = 45.0
Average = 42.35 , Standard deviation = 1.91
- Generation 2
Evaluated 277 individuals
Min = 37.0 , Max = 45.0
Average = 43.39 , Standard deviation = 1.46
… … … …
- Generation 9
Evaluated 299 individuals
Min = 40.0 , Max = 45.0
Average = 44.12 , Standard deviation = 1.11
- Evolution ends
Best individual:
[0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1,
1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0,
1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1]
Number of ones: 15

Problema de regresión de símbolos

Es uno de los problemas más conocidos en programación genética. Todos los

problemas de regresión simbólica utilizan una distribución de datos arbitraria e
intentan ajustar los datos más precisos con una fórmula simbólica. Por lo
general, una medida como el RMSE (Root Mean Square Error) se usa para
medir la aptitud de un individuo. Es un problema clásico de regresor y aquí
estamos usando la ecuación 5x 3 -6x 2 + 8x = 1 . Necesitamos seguir todos los
pasos que se siguen en el ejemplo anterior, pero la parte principal sería crear
los conjuntos primitivos porque son los bloques de construcción para los
individuos para que la evaluación pueda comenzar. Aquí usaremos el conjunto
clásico de primitivas.
El siguiente código de Python explica esto en detalle:
import operator
import math
import random
import numpy as np
from deap import algorithms, base, creator, tools, gp
def division_operator(numerator, denominator):
if denominator == 0:
return 1
return numerator / denominator
def eval_func(individual, points):
func = toolbox.compile(expr=individual)
return math.fsum(mse) / len(points),
def create_toolbox():
pset = gp.PrimitiveSet("MAIN", 1)
pset.addPrimitive(operator.add, 2)
pset.addPrimitive(operator.sub, 2)
pset.addPrimitive(operator.mul, 2)
pset.addPrimitive(division_operator, 2)
pset.addPrimitive(operator.neg, 1)
pset.addPrimitive(math.cos, 1)
pset.addPrimitive(math.sin, 1)
pset.addEphemeralConstant("rand101", lambda:
random.randint(-1,1))
pset.renameArguments(ARG0 = 'x')
creator.create("FitnessMin", base.Fitness, weights = (-
1.0,))

creator.create("Individual",gp.PrimitiveTree,fitness=creator.
FitnessMin)
toolbox = base.Toolbox()
toolbox.register("expr", gp.genHalfAndHalf, pset=pset,
min_=1, max_=2)
toolbox.expr)
toolbox.register("population",tools.initRepeat,list,
toolbox.individual)
toolbox.register("compile", gp.compile, pset = pset)
toolbox.register("evaluate", eval_func, points = [x/10.
for x in range(-10,10)])
toolbox.register("select", tools.selTournament, tournsize
= 3)
toolbox.register("mate", gp.cxOnePoint)
toolbox.register("expr_mut", gp.genFull, min_=0, max_=2)
 toolbox.register("mutate", gp.mutUniform, expr =
toolbox.expr_mut, pset = pset)
toolbox.decorate("mate", gp.staticLimit(key =
operator.attrgetter("height"), max_value = 17))
toolbox.decorate("mutate", gp.staticLimit(key =
operator.attrgetter("height"), max_value = 17))
return toolbox
if __name__ == "__main__":
random.seed(7)
toolbox = create_toolbox()
population = toolbox.population(n = 450)
hall_of_fame = tools.HallOfFame(1)
stats_fit = tools.Statistics(lambda x: x.fitness.values)
stats_size = tools.Statistics(len)
mstats = tools.MultiStatistics(fitness=stats_fit, size =
stats_size)
mstats.register("avg", np.mean)
mstats.register("std", np.std)
mstats.register("min", np.min)
mstats.register("max", np.max)
probab_crossover = 0.4
probab_mutate = 0.2
number_gen = 10
population, log = algorithms.eaSimple(population, toolbox,
probab_crossover, probab_mutate, number_gen,
stats = mstats, halloffame = hall_of_fame, verbose =
True)
Tenga en cuenta que todos los pasos básicos son los mismos que se utilizan
al generar patrones de bits. Este programa nos dará la salida como min, max,
std (desviación estándar) después de 10 número de generaciones.

AI con Python - Visión por computadora

La visión por computadora se relaciona con el modelado y la replicación de la
visión humana utilizando software y hardware. En este capítulo, aprenderá en
detalle sobre esto.

Visión por computador

La visión por computadora es una disciplina que estudia cómo reconstruir,
interrumpir y comprender una escena 3D a partir de sus imágenes 2D, en
términos de las propiedades de la estructura presente en la escena.

Jerarquía de visión por computadora

La visión por computadora se divide en tres categorías básicas de la siguiente

manera:
 Visión de bajo nivel : incluye imagen de proceso para extracción de
características.
  Visión de nivel intermedio : incluye reconocimiento de objetos e interpretación
de escenas en 3D
 Visión de alto nivel : incluye una descripción conceptual de una escena como
actividad, intención y comportamiento.

Procesamiento de imágenes de visión por

computadora vs.
El procesamiento de imágenes estudia la transformación de imagen a
imagen. La entrada y salida del procesamiento de imágenes son ambas
imágenes.
La visión por computadora es la construcción de descripciones explícitas y
significativas de objetos físicos a partir de su imagen. El resultado de la visión
por computadora es una descripción o una interpretación de estructuras en
una escena 3D.

Aplicaciones

La visión por computadora encuentra aplicaciones en los siguientes campos:

Robótica
 Localización: determine la ubicación del robot automáticamente
 Navegación
 Evitar obstáculos
 Ensamblaje (clavija en el orificio, soldadura, pintura)
 Manipulación (p. Ej. Manipulador robot PUMA)
 Human Robot Interaction (HRI): robótica inteligente para interactuar y servir a las
personas
Medicina
 Clasificación y detección (p. Ej., Clasificación de lesiones o células y detección de
tumores)
 Segmentación 2D / 3D
 Reconstrucción de órganos humanos en 3D (MRI o ultrasonido)
 Cirugía robótica guiada por visión
Seguridad

 Biometría (iris, huella digital, reconocimiento facial)

 Vigilancia: detección de ciertas actividades o comportamientos sospechosos
Transporte

 Vehículo autónomo
 Seguridad, por ejemplo, monitoreo de vigilancia del conductor
Aplicación de automatización industrial
  Inspección industrial (detección de defectos)
 Montaje
 Lectura de códigos de barras y etiquetas de paquetes
 Clasificación de objetos
 Comprensión de documentos (por ejemplo, OCR)

Instalar paquetes útiles

Para la visión por computadora con Python, puede usar una biblioteca popular
llamada OpenCV (Open Source Computer Vision). Es una biblioteca de
funciones de programación dirigida principalmente a la visión por computadora
en tiempo real. Está escrito en C ++ y su interfaz principal está en C
++. Puede instalar este paquete con la ayuda del siguiente comando:
pip install opencv_python-X.X-cp36-cp36m-winX.whl
Aquí X representa la versión de Python instalada en su máquina, así como el
win32 o 64 bit que está teniendo.
Si está utilizando el entorno anaconda , utilice el siguiente comando para
instalar OpenCV:
conda install -c conda-forge opencv

Leer, escribir y mostrar una imagen

La mayoría de las aplicaciones de CV necesitan obtener las imágenes como
entrada y producir las imágenes como salida. En esta sección, aprenderá a
leer y escribir archivos de imagen con la ayuda de las funciones
proporcionadas por OpenCV.

Funciones de OpenCV para leer, mostrar, escribir un archivo de

imagen

OpenCV proporciona las siguientes funciones para este propósito:

 Función imread () : esta es la función para leer una imagen. OpenCV imread ()
admite varios formatos de imagen como PNG, JPEG, JPG, TIFF, etc.
 Función imshow () : esta es la función para mostrar una imagen en una
ventana. La ventana se ajusta automáticamente al tamaño de la imagen. OpenCV
imshow () admite varios formatos de imagen como PNG, JPEG, JPG, TIFF, etc.
 imwrite función () - Esta es la función para la escritura de una imagen. OpenCV
imwrite () admite varios formatos de imagen como PNG, JPEG, JPG, TIFF, etc.

Ejemplo

Este ejemplo muestra el código de Python para leer una imagen en un

formato, mostrándola en una ventana y escribiendo la misma imagen en otro
formato. Considere los pasos que se muestran a continuación:
Importe el paquete OpenCV como se muestra:
import cv2
Ahora, para leer una imagen en particular, use la función imread () -
image = cv2.imread('image_flower.jpg')
Para mostrar la imagen, use la función imshow () . El nombre de la ventana
en la que puede ver la imagen sería image_flower .
cv2.imshow('image_flower',image)
cv2.destroyAllwindows()

Ahora, podemos escribir la misma imagen en otro formato, digamos .png

usando la función imwrite () -
cv2.imwrite('image_flower.png',image)
La salida True significa que la imagen se ha escrito correctamente como
archivo .png también en la misma carpeta.
True
Nota: la función destroyallWindows () simplemente destruye todas las
ventanas que creamos.

Conversión de espacio de color

En OpenCV, las imágenes no se almacenan utilizando el color RGB
convencional, sino que se almacenan en el orden inverso, es decir, en el
orden BGR. Por lo tanto, el código de color predeterminado al leer una imagen
es BGR. La función de conversión de color cvtColor () sirve para convertir la
imagen de un código de color a otro.

Ejemplo

Considere este ejemplo para convertir la imagen de BGR a escala de grises.

Importe el paquete OpenCV como se muestra:
import cv2
Ahora, para leer una imagen en particular, use la función imread () -
image = cv2.imread('image_flower.jpg')
Ahora, si vemos esta imagen usando la función imshow () , entonces
podemos ver que esta imagen está en BGR.
cv2.imshow('BGR_Penguins',image)

Ahora, use la función cvtColor () para convertir esta imagen a escala de

grises.
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
cv2.imshow('gray_penguins',image)

Detección de bordes
Los humanos, después de ver un esbozo, pueden reconocer fácilmente
muchos tipos de objetos y sus poses. Es por eso que los bordes juegan un
papel importante en la vida de los humanos, así como en las aplicaciones de
la visión por computadora. OpenCV proporciona una función muy simple y útil
llamada Canny () para detectar los bordes.

Ejemplo

El siguiente ejemplo muestra una identificación clara de los bordes.

Importe el paquete OpenCV como se muestra:
import cv2
import numpy as np
Ahora, para leer una imagen en particular, use la función imread () .
image = cv2.imread('Penguins.jpg')
Ahora, use la función Canny () para detectar los bordes de la imagen ya leída.
cv2.imwrite(„edges_Penguins.jpg‟,cv2.Canny(image,200,300))
Ahora, para mostrar la imagen con bordes, use la función imshow ().
cv2.imshow(„edges‟, cv2.imread(„„edges_Penguins.jpg‟))
Este programa de Python creará una imagen llamada edge_penguins.jpg con
detección de bordes.

Detección de rostro
La detección de rostros es una de las aplicaciones fascinantes de la visión por
computadora que la hace más realista y futurista. OpenCV tiene una
instalación incorporada para realizar la detección de rostros. Vamos a utilizar
el clasificador en cascada Haar para la detección de rostros.

Haar Cascade Data

Necesitamos datos para usar el clasificador en cascada Haar. Puede

encontrar estos datos en nuestro paquete OpenCV. Después de instalar
OpenCv, puede ver el nombre de la carpeta haarcascades . Habría archivos
.xml para diferentes aplicaciones. Ahora, cópielos todos para un uso diferente
y péguelos en una nueva carpeta debajo del proyecto actual.
Ejemplo
El siguiente es el código de Python usando Haar Cascade para detectar la
cara de Amitabh Bachan que se muestra en la siguiente imagen:

Importe el paquete OpenCV como se muestra:

import cv2
import numpy as np
Ahora, use el HaarCascadeClassifier para detectar caras:
face_detection=
cv2.CascadeClassifier('D:/ProgramData/cascadeclassifier/
haarcascade_frontalface_default.xml')
Ahora, para leer una imagen en particular, use la función imread () -
img = cv2.imread('AB.jpg')
Ahora, conviértalo en escala de grises porque aceptaría imágenes grises:
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
Ahora, usando face_detection.detectMultiScale , realice la detección de
rostros real
faces = face_detection.detectMultiScale(gray, 1.3, 5)
Ahora, dibuja un rectángulo alrededor de toda la cara:
for (x,y,w,h) in faces:
img = cv2.rectangle(img,(x,y),(x+w, y+h),(255,0,0),3)
cv2.imwrite('Face_AB.jpg',img)
Este programa Python creará una imagen llamada Face_AB.jpg con
detección de rostros como se muestra
Detección de ojos
La detección ocular es otra aplicación fascinante de la visión por computadora
que la hace más realista y futurista. OpenCV tiene una instalación incorporada
para realizar la detección ocular. Vamos a utilizar el clasificador en cascada
Haar para la detección ocular.

Ejemplo

El siguiente ejemplo proporciona el código de Python usando Haar Cascade

para detectar la cara de Amitabh Bachan que se muestra en la siguiente
imagen:

Importe el paquete OpenCV como se muestra:

import cv2
import numpy as np
Ahora, use el HaarCascadeClassifier para detectar caras:
eye_cascade =
cv2.CascadeClassifier('D:/ProgramData/cascadeclassifier/haarc
ascade_eye.xml')
Ahora, para leer una imagen en particular, use la función imread ()
img = cv2.imread('AB_Eye.jpg')
Ahora, conviértalo en escala de grises porque aceptaría imágenes grises:
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
Ahora con la ayuda de eye_cascade.detectMultiScale , realice la detección
de rostros real
eyes = eye_cascade.detectMultiScale(gray, 1.03, 5)
Ahora, dibuja un rectángulo alrededor de toda la cara:
for (ex,ey,ew,eh) in eyes:
img = cv2.rectangle(img,(ex,ey),(ex+ew,
ey+eh),(0,255,0),2)
cv2.imwrite('Eye_AB.jpg',img)
Este programa de Python creará una imagen llamada Eye_AB.jpg con
detección ocular como se muestra:

AI con Python - Aprendizaje profundo

La red neuronal artificial (ANN) es un sistema informático eficiente, cuyo tema
central está tomado de la analogía de las redes neuronales biológicas. Las
redes neuronales son un tipo de modelo para el aprendizaje automático. A
mediados de los años ochenta y principios de los noventa, se hicieron avances
arquitectónicos muy importantes en las redes neuronales. En este capítulo,
aprenderá más sobre Deep Learning, un enfoque de IA.
El aprendizaje profundo surgió del explosivo crecimiento computacional de
una década como un serio contendiente en el campo. Por lo tanto, el
aprendizaje profundo es un tipo particular de aprendizaje automático cuyos
algoritmos están inspirados en la estructura y función del cerebro humano.

Aprendizaje automático v / s Aprendizaje profundo

El aprendizaje profundo es la técnica de aprendizaje automático más potente
en estos días. Es muy poderoso porque aprenden la mejor manera de
representar el problema mientras aprenden cómo resolverlo. A continuación se
ofrece una comparación del aprendizaje profundo y el aprendizaje automático:

Dependencia de datos
El primer punto de diferencia se basa en el rendimiento de DL y ML cuando
aumenta la escala de datos. Cuando los datos son grandes, los algoritmos de
aprendizaje profundo funcionan muy bien.

Dependencia de la máquina

Los algoritmos de aprendizaje profundo necesitan máquinas de alta gama

para funcionar perfectamente. Por otro lado, los algoritmos de aprendizaje
automático también pueden funcionar en máquinas de gama baja.

Extracción de características

Los algoritmos de aprendizaje profundo pueden extraer características de alto

nivel e intentar aprender de lo mismo también. Por otro lado, se requiere un
experto para identificar la mayoría de las características extraídas por el
aprendizaje automático.

Tiempo de ejecución

El tiempo de ejecución depende de los numerosos parámetros utilizados en un

algoritmo. El aprendizaje profundo tiene más parámetros que los algoritmos de
aprendizaje automático. Por lo tanto, el tiempo de ejecución de los algoritmos
DL, especialmente el tiempo de entrenamiento, es mucho más que los
algoritmos ML. Pero el tiempo de prueba de los algoritmos DL es menor que
los algoritmos ML.

Enfoque para resolver problemas

El aprendizaje profundo resuelve el problema de principio a fin, mientras que

el aprendizaje automático utiliza la forma tradicional de resolver el problema,
es decir, dividiéndolo en partes.

Red neuronal convolucional (CNN)

Las redes neuronales convolucionales son las mismas que las redes
neuronales ordinarias porque también están formadas por neuronas que
tienen pesos y sesgos aprendibles. Las redes neuronales ordinarias ignoran la
estructura de los datos de entrada y todos los datos se convierten en una
matriz 1-D antes de alimentarlos a la red. Este proceso se adapta a los datos
normales, sin embargo, si los datos contienen imágenes, el proceso puede ser
engorroso.
CNN resuelve este problema fácilmente. Toma en cuenta la estructura 2D de
las imágenes cuando las procesan, lo que les permite extraer las propiedades
específicas de las imágenes. De esta manera, el objetivo principal de los CNN
es pasar de los datos de imagen sin procesar en la capa de entrada a la clase
correcta en la capa de salida. La única diferencia entre un NN ordinario y un
CNN está en el tratamiento de los datos de entrada y en el tipo de capas.
Descripción general de la arquitectura de CNN

Arquitectónicamente, las redes neuronales ordinarias reciben una entrada y la

transforman a través de una serie de capas ocultas. Cada capa está
conectada a la otra capa con la ayuda de las neuronas. La principal
desventaja de las redes neuronales comunes es que no se adaptan bien a
imágenes completas.
La arquitectura de las CNN tiene neuronas dispuestas en 3 dimensiones
llamadas ancho, alto y profundidad. Cada neurona en la capa actual está
conectada a un pequeño parche de la salida de la capa anterior. Es similar a
superponer un filtro 𝑵 × 𝑵 en la imagen de entrada. Utiliza filtros M para
asegurarse de obtener todos los detalles. Estos filtros M son extractores de
características que extraen características como bordes, esquinas, etc.

Capas utilizadas para construir CNN

Las siguientes capas se utilizan para construir CNN:

 Capa de entrada : toma los datos de imagen sin procesar tal como están.
 Capa convolucional : esta capa es el bloque de construcción central de las CNN
que realiza la mayoría de los cálculos. Esta capa calcula las convoluciones entre
las neuronas y los diversos parches en la entrada.
 Capa de unidad lineal rectificada : aplica una función de activación a la salida de
la capa anterior. Agrega no linealidad a la red para que pueda generalizarse bien
a cualquier tipo de función.
 Capa de agrupación : la agrupación nos ayuda a mantener solo las partes
importantes a medida que avanzamos en la red. La capa de agrupación funciona
independientemente en cada segmento de profundidad de la entrada y la
redimensiona espacialmente. Utiliza la función MAX.
 Capa completamente conectada / Capa de salida : esta capa calcula las
puntuaciones de salida en la última capa. La salida resultante es del tamaño 𝟏 × 𝟏
× 𝑳 , donde L es el número de clases de conjunto de datos de entrenamiento.

Instalar paquetes útiles de Python

Puede usar Keras , que es una API de redes neuronales de alto nivel, escrita
en Python y capaz de ejecutarse sobre TensorFlow, CNTK o Theno. Es
compatible con Python 2.7-3.6. Puede obtener más información al respecto
en https://keras.io/ .
Use los siguientes comandos para instalar keras:
pip install keras
En el entorno conda , puede usar el siguiente comando:
conda install –c conda-forge keras

Construyendo Regresor Lineal usando ANN

En esta sección, aprenderá cómo construir un regresor lineal utilizando redes
neuronales artificiales. Puede usar KerasRegressor para lograr esto. En este
ejemplo, estamos utilizando el conjunto de datos de precios de la vivienda de
Boston con 13 numéricos para propiedades en Boston. El código de Python
para el mismo se muestra aquí:
Importe todos los paquetes necesarios como se muestra:
import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
Ahora, cargue nuestro conjunto de datos que se guarda en el directorio local.
dataframe = pandas.read_csv("/Usrrs/admin/data.csv",
delim_whitespace = True, header = None)
dataset = dataframe.values
Ahora, divida los datos en variables de entrada y salida, es decir, X e Y -
X = dataset[:,0:13]
Y = dataset[:,13]
Dado que usamos redes neuronales de referencia, defina el modelo:
def baseline_model():
Ahora, cree el modelo de la siguiente manera:
model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13,
kernel_initializer = 'normal',
activation = 'relu'))
model_regressor.add(Dense(1, kernel_initializer = 'normal'))
A continuación, compile el modelo:
model_regressor.compile(loss='mean_squared_error',
optimizer='adam')
return model_regressor
Ahora, arregle la semilla aleatoria para la reproducibilidad de la siguiente
manera:
seed = 7
numpy.random.seed(seed)
El objeto envoltorio Keras para usar en scikit-learn como estimador de
regresión se llama KerasRegressor . En esta sección, evaluaremos este
modelo con un conjunto de datos estandarizado.
estimator = KerasRegressor(build_fn = baseline_model,
nb_epoch = 100, batch_size = 5, verbose = 0)
kfold = KFold(n_splits = 10, random_state = seed)
baseline_result = cross_val_score(estimator, X, Y, cv =
kfold)
print("Baseline: %.2f (%.2f) MSE" %
(Baseline_result.mean(),Baseline_result.std()))

El resultado del código que se muestra arriba sería la estimación del

rendimiento del modelo en el problema para datos no vistos. Será el error
cuadrático medio, incluida la desviación promedio y estándar en los 10
pliegues de la evaluación de validación cruzada.

Clasificador de imágenes: una aplicación de

aprendizaje profundo
Las redes neuronales convolucionales (CNN) resuelven un problema de
clasificación de imágenes, es decir, a qué clase pertenece la imagen de
entrada. Puede usar la biblioteca de aprendizaje profundo Keras. Tenga en
cuenta que estamos utilizando el conjunto de datos de entrenamiento y
pruebas de imágenes de gatos y perros del siguiente
enlace https://www.kaggle.com/c/dogs-vs-cats/data .
Importe las bibliotecas y paquetes importantes de keras como se muestra:
El siguiente paquete llamado secuencial inicializará las redes neuronales
como red secuencial.
from keras.models import Sequential
El siguiente paquete llamado Conv2D se utiliza para realizar la operación de
convolución, el primer paso de CNN.
from keras.layers import Conv2D
El siguiente paquete llamado MaxPoling2D se utiliza para realizar la
operación de agrupación, el segundo paso de CNN.
from keras.layers import MaxPooling2D
El siguiente paquete llamado Flatten es el proceso de convertir todas las
matrices 2D resultantes en un único vector lineal continuo largo.
from keras.layers import Flatten
El siguiente paquete llamado Denso se usa para realizar la conexión completa
de la red neuronal, el cuarto paso de CNN.
from keras.layers import Dense
Ahora, cree un objeto de la clase secuencial.
S_classifier = Sequential()
Ahora, el siguiente paso es codificar la parte de convolución.
S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64,
3), activation = 'relu'))
Aquí relu es la función rectificadora.
Ahora, el siguiente paso de CNN es la operación de agrupación en los mapas
de características resultantes después de la parte de convolución.
S-classifier.add(MaxPooling2D(pool_size = (2, 2)))
Ahora, convierta todas las imágenes agrupadas en un vector continuo
utilizando halagadores:
S_classifier.add(Flatten())

A continuación, cree una capa totalmente conectada.

S_classifier.add(Dense(units = 128, activation = 'relu'))
Aquí, 128 es el número de unidades ocultas. Es una práctica común definir el
número de unidades ocultas como el poder de 2.
Ahora, inicialice la capa de salida de la siguiente manera:
S_classifier.add(Dense(units = 1, activation = 'sigmoid'))
Ahora, compile la CNN, hemos construido -
S_classifier.compile(optimizer = 'adam', loss =
'binary_crossentropy', metrics = ['accuracy'])

Aquí el parámetro optimizador es elegir el algoritmo de descenso de gradiente

estocástico, el parámetro de pérdida es elegir la función de pérdida y el
parámetro de métrica es elegir la métrica de rendimiento.
Ahora, realice aumentos de imagen y luego ajuste las imágenes a las redes
neuronales:
train_datagen = ImageDataGenerator(rescale =
1./255,shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)

training_set =

train_datagen.flow_from_directory(”/Users/admin/training_set”
,target_size =
(64, 64),batch_size = 32,class_mode = 'binary')

test_set =
test_datagen.flow_from_directory('test_set',target_size =
(64, 64),batch_size = 32,class_mode = 'binary')
Ahora, ajuste los datos al modelo que hemos creado:
classifier.fit_generator(training_set,steps_per_epoch =
8000,epochs =
25,validation_data = test_set,validation_steps = 2000)
Aquí steps_per_epoch tiene el número de imágenes de entrenamiento.
Ahora que el modelo ha sido entrenado, podemos usarlo para la predicción de
la siguiente manera:
from keras.preprocessing import image

test_image =
image.load_img('dataset/single_prediction/cat_or_dog_1.jpg',
target_size = (64, 64))

test_image = image.img_to_array(test_image)

test_image = np.expand_dims(test_image, axis = 0)

result = classifier.predict(test_image)

training_set.class_indices

if result[0][0] == 1:
prediction = 'dog'

else:
prediction = 'cat'