AI com Python - Guia rápido
Desde a invenção de computadores ou máquinas, sua capacidade de executar várias tarefas experimentou um crescimento exponencial. Os humanos desenvolveram o poder dos sistemas de computador em termos de seus diversos domínios de trabalho, sua velocidade crescente e tamanho reduzido em relação ao tempo.
Um ramo da Ciência da Computação denominado Inteligência Artificial busca criar computadores ou máquinas tão inteligentes quanto seres humanos.
Conceito Básico de Inteligência Artificial (IA)
Segundo o pai da Inteligência Artificial, John McCarthy, é “A ciência e a engenharia de fazer máquinas inteligentes, principalmente programas de computador inteligentes”.
A Inteligência Artificial é uma maneira de fazer um computador, um robô controlado por computador ou um software pensar de forma inteligente, da mesma maneira que os humanos inteligentes pensam. A IA é realizada estudando como o cérebro humano pensa e como os humanos aprendem, decidem e trabalham enquanto tentam resolver um problema e, em seguida, usam os resultados deste estudo como base para o desenvolvimento de software e sistemas inteligentes.
Ao explorar o poder dos sistemas de computador, a curiosidade do ser humano, o leva a se perguntar: "Uma máquina pode pensar e se comportar como os humanos?"
Assim, o desenvolvimento da IA começou com a intenção de criar inteligência semelhante em máquinas que encontramos e consideramos alta nos humanos.
A necessidade de aprender IA
Como sabemos, a IA busca criar máquinas tão inteligentes quanto os seres humanos. Existem inúmeras razões para estudarmos IA. As razões são as seguintes -
IA pode aprender por meio de dados
Em nossa vida diária, lidamos com uma grande quantidade de dados e o cérebro humano não consegue controlar tantos dados. É por isso que precisamos automatizar as coisas. Para fazer automação, precisamos estudar IA, pois ela pode aprender com os dados e fazer as tarefas repetitivas com precisão e sem cansaço.
AI pode ensinar a si mesma
É muito necessário que um sistema ensine a si mesmo, porque os próprios dados estão sempre mudando e o conhecimento que é derivado de tais dados deve ser atualizado constantemente. Podemos usar IA para cumprir esse propósito porque um sistema habilitado para IA pode ensinar a si mesmo.
AI pode responder em tempo real
A inteligência artificial com a ajuda de redes neurais pode analisar os dados mais profundamente. Devido a esta capacidade, a IA pode pensar e responder às situações que se baseiam nas condições em tempo real.
IA alcança precisão
Com a ajuda de redes neurais profundas, a IA pode atingir uma precisão tremenda. AI ajuda no campo da medicina a diagnosticar doenças como o câncer a partir de ressonâncias magnéticas de pacientes.
A IA pode organizar os dados para obter o máximo deles
Os dados são propriedade intelectual dos sistemas que utilizam algoritmos de autoaprendizagem. Precisamos da IA para indexar e organizar os dados de uma forma que sempre forneça os melhores resultados.
Compreendendo a inteligência
Com IA, sistemas inteligentes podem ser construídos. Precisamos entender o conceito de inteligência para que nosso cérebro possa construir outro sistema de inteligência como ele mesmo.
O que é inteligência?
A capacidade de um sistema de calcular, raciocinar, perceber relações e analogias, aprender com a experiência, armazenar e recuperar informações da memória, resolver problemas, compreender ideias complexas, usar linguagem natural com fluência, classificar, generalizar e adaptar novas situações.
Tipos de Inteligência
Conforme descrito por Howard Gardner, um psicólogo do desenvolvimento americano, a inteligência vem em múltiplas -
Sr. Não | Inteligência e descrição | Exemplo |
---|---|---|
1 | Linguistic intelligence A capacidade de falar, reconhecer e usar mecanismos de fonologia (sons da fala), sintaxe (gramática) e semântica (significado). |
Narradores, oradores |
2 | Musical intelligence A capacidade de criar, comunicar e compreender os significados do som, compreensão do tom, ritmo. |
Músicos, cantores, compositores |
3 | Logical-mathematical intelligence A capacidade de usar e compreender relacionamentos na ausência de ação ou objetos. É também a capacidade de compreender ideias complexas e abstratas. |
Matemáticos, Cientistas |
4 | Spatial intelligence A capacidade de perceber informações visuais ou espaciais, alterá-las e recriar imagens visuais sem referência aos objetos, construir imagens 3D e movê-las e girá-las. |
Leitores de mapas, astronautas, físicos |
5 | Bodily-Kinesthetic intelligence A capacidade de usar todo ou parte do corpo para resolver problemas ou produtos de moda, controlar habilidades motoras finas e grosseiras e manipular objetos. |
Jogadores, dançarinos |
6 | Intra-personal intelligence A capacidade de distinguir entre os próprios sentimentos, intenções e motivações. |
Gautam Buddhha |
7 | Interpersonal intelligence A capacidade de reconhecer e fazer distinções entre os sentimentos, crenças e intenções de outras pessoas. |
Comunicadores de massa, entrevistadores |
Você pode dizer que uma máquina ou sistema é artificialmente inteligente quando está equipado com pelo menos uma ou todas as inteligências.
De que é composta a inteligência?
A inteligência é intangível. É composto por -
- Reasoning
- Learning
- Solução de problemas
- Perception
- Inteligência Lingüística
Vamos examinar todos os componentes brevemente -
Raciocínio
É o conjunto de processos que nos permite fornecer uma base para julgamento, tomada de decisões e previsão. Existem basicamente dois tipos -
Raciocínio indutivo | Raciocínio dedutivo |
---|---|
Ele realiza observações específicas para fazer declarações gerais gerais. | Ele começa com uma declaração geral e examina as possibilidades de se chegar a uma conclusão lógica específica. |
Mesmo que todas as premissas sejam verdadeiras em uma afirmação, o raciocínio indutivo permite que a conclusão seja falsa. | Se algo é verdade para uma classe de coisas em geral, também é verdade para todos os membros dessa classe. |
Example - "Nita é professora. Nita é estudiosa. Portanto, todos os professores são estudiosos." | Example - “Todas as mulheres com mais de 60 anos são avós. Shalini tem 65 anos. Portanto, Shalini é avó”. |
Aprendizagem - l
A capacidade de aprendizagem é possuída por humanos, espécies particulares de animais e sistemas habilitados para IA. A aprendizagem é categorizada da seguinte forma -
Aprendizagem Auditiva
É aprender ouvindo e ouvindo. Por exemplo, alunos ouvindo palestras em áudio gravadas.
Aprendizagem episódica
Para aprender lembrando-se de sequências de eventos que alguém testemunhou ou experimentou. Isso é linear e ordenado.
Aprendizagem Motora
É aprender pelo movimento preciso dos músculos. Por exemplo, escolher objetos, escrever, etc.
Aprendizagem por observação
Para aprender observando e imitando os outros. Por exemplo, a criança tenta aprender imitando seu pai.
Aprendizagem Perceptual
É aprender a reconhecer os estímulos que já se viu. Por exemplo, identificar e classificar objetos e situações.
Aprendizagem Relacional
Envolve aprender a diferenciar entre vários estímulos com base em propriedades relacionais, ao invés de propriedades absolutas. Por exemplo, adicionar um pouco menos de sal na hora de cozinhar batatas que ficaram salgadas da última vez, quando cozidas com adição, digamos de uma colher de sopa de sal.
Spatial Learning - É aprender por meio de estímulos visuais, como imagens, cores, mapas, etc. Por exemplo, uma pessoa pode criar um roteiro na mente antes de realmente seguir a estrada.
Stimulus-Response Learning- É aprender a realizar um determinado comportamento quando um determinado estímulo está presente. Por exemplo, um cachorro levanta a orelha ao ouvir a campainha.
Solução de problemas
É o processo no qual se percebe e tenta chegar a uma solução desejada a partir de uma situação presente, seguindo algum caminho, que está bloqueado por obstáculos conhecidos ou desconhecidos.
A resolução de problemas também inclui decision making, que é o processo de selecionar a alternativa mais adequada entre várias alternativas para atingir o objetivo desejado.
Percepção
É o processo de aquisição, interpretação, seleção e organização das informações sensoriais.
A percepção presume sensing. Em humanos, a percepção é auxiliada por órgãos sensoriais. No domínio da IA, o mecanismo de percepção reúne os dados adquiridos pelos sensores de maneira significativa.
Inteligência Lingüística
É a habilidade de usar, compreender, falar e escrever a linguagem verbal e escrita. É importante na comunicação interpessoal.
O que está envolvido na IA
A inteligência artificial é uma vasta área de estudo. Este campo de estudo ajuda a encontrar soluções para problemas do mundo real.
Vamos agora ver os diferentes campos de estudo da IA -
Aprendizado de Máquina
É um dos campos mais populares da IA. O conceito básico deste campo é fazer o aprendizado de máquina a partir dos dados como o ser humano pode aprender com a sua experiência. Ele contém modelos de aprendizagem com base nos quais as previsões podem ser feitas com base em dados desconhecidos.
Lógica
É outro importante campo de estudo no qual a lógica matemática é usada para executar os programas de computador. Ele contém regras e fatos para realizar correspondência de padrões, análise semântica, etc.
Procurando
Este campo de estudo é usado basicamente em jogos como xadrez, jogo da velha. Os algoritmos de pesquisa fornecem a solução ideal após pesquisar todo o espaço de pesquisa.
Redes neurais artificiais
Esta é uma rede de sistemas de computação eficientes, cujo tema central é emprestado da analogia das redes neurais biológicas. A ANN pode ser usada em robótica, reconhecimento de fala, processamento de fala, etc.
Algoritmo genético
Algoritmos genéticos auxiliam na solução de problemas com o auxílio de mais de um programa. O resultado seria baseado na seleção do mais apto.
Representação de Conhecimento
É o campo de estudo com o qual podemos representar os fatos de uma forma que a máquina seja compreensível para a máquina. Quanto mais eficientemente o conhecimento é representado; quanto mais sistema seria inteligente.
Aplicação de IA
Nesta seção, veremos os diferentes campos suportados pela IA -
Jogos
A IA desempenha um papel crucial em jogos estratégicos como xadrez, pôquer, jogo da velha, etc., onde a máquina pode pensar em um grande número de posições possíveis com base no conhecimento heurístico.
Processamento de linguagem natural
É possível interagir com o computador que entende a linguagem natural falada por humanos.
Sistemas especializados
Existem alguns aplicativos que integram máquina, software e informações especiais para transmitir raciocínio e aconselhamento. Eles fornecem explicações e conselhos aos usuários.
Sistemas de Visão
Esses sistemas entendem, interpretam e compreendem a entrada visual do computador. Por exemplo,
Um avião espião tira fotos, que são usadas para descobrir informações espaciais ou mapear as áreas.
Os médicos usam o sistema especialista clínico para diagnosticar o paciente.
A polícia usa um software de computador que pode reconhecer o rosto do criminoso com o retrato armazenado feito pelo artista forense.
Reconhecimento de fala
Alguns sistemas inteligentes são capazes de ouvir e compreender a linguagem em termos de frases e seus significados enquanto um humano fala com ela. Ele pode lidar com diferentes sotaques, gírias, ruído de fundo, mudança no ruído humano devido ao frio, etc.
Reconhecimento de caligrafia
O software de reconhecimento de escrita lê o texto escrito no papel por uma caneta ou na tela por uma caneta. Ele pode reconhecer as formas das letras e convertê-las em texto editável.
Robôs Inteligentes
Os robôs são capazes de realizar as tarefas atribuídas por um humano. Eles têm sensores para detectar dados físicos do mundo real, como luz, calor, temperatura, movimento, som, impacto e pressão. Eles têm processadores eficientes, vários sensores e grande memória, para exibir inteligência. Além disso, eles são capazes de aprender com seus erros e podem se adaptar ao novo ambiente.
Modelagem Cognitiva: Simulando Procedimento de Pensamento Humano
Modelagem cognitiva é basicamente o campo de estudo da ciência da computação que trata do estudo e simulação do processo de pensamento do ser humano. A principal tarefa da IA é fazer a máquina pensar como um ser humano. A característica mais importante do processo de pensamento humano é a resolução de problemas. É por isso que a modelagem mais ou menos cognitiva tenta entender como os humanos podem resolver os problemas. Depois disso, este modelo pode ser usado para várias aplicações de IA, como aprendizado de máquina, robótica, processamento de linguagem natural, etc. A seguir está o diagrama dos diferentes níveis de pensamento do cérebro humano -
Agente e Meio Ambiente
Nesta seção, enfocaremos o agente e o ambiente e como eles ajudam na Inteligência Artificial.
Agente
Um agente é qualquer coisa que pode perceber seu ambiente por meio de sensores e atuar nesse ambiente por meio de efetores.
UMA human agent tem órgãos sensoriais, como olhos, ouvidos, nariz, língua e pele paralelos aos sensores, e outros órgãos, como mãos, pernas, boca, para efetores.
UMA robotic agent substitui câmeras e telêmetros infravermelhos para os sensores e vários motores e atuadores para efetores.
UMA software agent codificou cadeias de bits como seus programas e ações.
Meio Ambiente
Alguns programas operam inteiramente artificial environment confinado à entrada do teclado, banco de dados, sistemas de arquivos de computador e saída de caracteres em uma tela.
Em contraste, alguns agentes de software (robôs de software ou softbots) existem em domínios de softbots ricos e ilimitados. O simulador tem umvery detailed, complex environment. O agente de software precisa escolher entre uma grande variedade de ações em tempo real. Um softbot é projetado para escanear as preferências online do cliente e mostra itens interessantes para os trabalhos do cliente noreal bem como um artificial meio Ambiente.
Neste capítulo, aprenderemos como começar a usar Python. Também entenderemos como o Python ajuda na Inteligência Artificial.
Por que Python para IA
A inteligência artificial é considerada a tendência de tecnologia do futuro. Já existem várias aplicações feitas nele. Por conta disso, muitas empresas e pesquisadores estão se interessando por ela. Mas a principal questão que surge aqui é em qual linguagem de programação esses aplicativos de IA podem ser desenvolvidos? Existem várias linguagens de programação como Lisp, Prolog, C ++, Java e Python, que podem ser utilizadas para o desenvolvimento de aplicações de IA. Entre eles, a linguagem de programação Python ganha uma enorme popularidade e os motivos são os seguintes -
Sintaxe simples e menos codificação
Python envolve muito menos codificação e sintaxe simples entre outras linguagens de programação que podem ser usadas para desenvolver aplicativos de IA. Devido a esse recurso, o teste pode ser mais fácil e podemos nos concentrar mais na programação.
Bibliotecas integradas para projetos de IA
Uma grande vantagem de usar Python para AI é que ele vem com bibliotecas embutidas. Python tem bibliotecas para quase todos os tipos de projetos de IA. Por exemplo,NumPy, SciPy, matplotlib, nltk, SimpleAI são algumas das importantes bibliotecas integradas do Python.
Open source- Python é uma linguagem de programação de código aberto. Isso o torna muito popular na comunidade.
Can be used for broad range of programming- Python pode ser usado para uma ampla gama de tarefas de programação, como pequenos scripts de shell para aplicativos da web corporativos. Este é outro motivo pelo qual o Python é adequado para projetos de IA.
Recursos do Python
Python é uma linguagem de script de alto nível, interpretada, interativa e orientada a objetos. Python foi projetado para ser altamente legível. Ele usa palavras-chave em inglês com frequência, enquanto outros idiomas usam pontuação e tem menos construções sintáticas do que outros idiomas. Os recursos do Python incluem o seguinte -
Easy-to-learn- Python tem poucas palavras-chave, estrutura simples e uma sintaxe claramente definida. Isso permite que o aluno aprenda o idioma rapidamente.
Easy-to-read - O código Python é mais claramente definido e visível aos olhos.
Easy-to-maintain - O código-fonte do Python é bastante fácil de manter.
A broad standard library - A maior parte da biblioteca do Python é muito portátil e compatível com várias plataformas em UNIX, Windows e Macintosh.
Interactive Mode - Python tem suporte para um modo interativo que permite teste interativo e depuração de trechos de código.
Portable - Python pode ser executado em uma ampla variedade de plataformas de hardware e tem a mesma interface em todas as plataformas.
Extendable- Podemos adicionar módulos de baixo nível ao interpretador Python. Esses módulos permitem que os programadores adicionem ou personalizem suas ferramentas para serem mais eficientes.
Databases - Python fornece interfaces para todos os principais bancos de dados comerciais.
GUI Programming - Python suporta aplicativos GUI que podem ser criados e transferidos para muitas chamadas de sistema, bibliotecas e sistemas Windows, como Windows MFC, Macintosh e o sistema X Window do Unix.
Scalable - Python fornece uma estrutura e suporte melhores para programas grandes do que scripts de shell.
Recursos importantes do Python
Vamos agora considerar os seguintes recursos importantes do Python -
Ele suporta métodos de programação funcionais e estruturados, bem como OOP.
Ele pode ser usado como uma linguagem de script ou pode ser compilado em código de bytes para a construção de grandes aplicativos.
Ele fornece tipos de dados dinâmicos de alto nível e oferece suporte à verificação de tipo dinâmico.
Ele oferece suporte à coleta de lixo automática.
Pode ser facilmente integrado com C, C ++, COM, ActiveX, CORBA e Java.
Instalando Python
A distribuição Python está disponível para um grande número de plataformas. Você precisa baixar apenas o código binário aplicável à sua plataforma e instalar o Python.
Se o código binário para sua plataforma não estiver disponível, você precisa de um compilador C para compilar o código-fonte manualmente. Compilar o código-fonte oferece mais flexibilidade em termos de escolha de recursos que você precisa em sua instalação.
Aqui está uma rápida visão geral da instalação do Python em várias plataformas -
Instalação Unix e Linux
Siga estas etapas para instalar o Python em uma máquina Unix / Linux.
Abra um navegador da Web e vá para https://www.python.org/downloads
Siga o link para baixar o código-fonte compactado disponível para Unix / Linux.
Baixe e extraia arquivos.
Editando o arquivo Módulos / Configuração se desejar personalizar algumas opções.
execute o script ./configure
make
faça a instalação
Isso instala o Python no local padrão / usr / local / bin e suas bibliotecas em / usr / local / lib / pythonXX onde XX é a versão do Python.
Instalação Windows
Siga estas etapas para instalar o Python na máquina Windows.
Abra um navegador da Web e vá para https://www.python.org/downloads
Siga o link do arquivo python-XYZ .msi do instalador do Windows, em que XYZ é a versão que você precisa instalar.
Para usar este instalador python-XYZ .msi, o sistema Windows deve suportar o Microsoft Installer 2.0. Salve o arquivo do instalador em sua máquina local e execute-o para descobrir se sua máquina oferece suporte a MSI.
Execute o arquivo baixado. Isso abre o assistente de instalação do Python, que é realmente fácil de usar. Basta aceitar as configurações padrão e esperar até que a instalação seja concluída.
Instalação Macintosh
Se você estiver no Mac OS X, é recomendado que você use o Homebrew para instalar o Python 3. É um ótimo instalador de pacotes para Mac OS X e é realmente fácil de usar. Se você não tiver o Homebrew, pode instalá-lo usando o seguinte comando -
$ ruby -e "$(curl -fsSL
https://raw.githubusercontent.com/Homebrew/install/master/install)"
Podemos atualizar o gerenciador de pacotes com o comando abaixo -
$ brew update
Agora execute o seguinte comando para instalar o Python3 em seu sistema -
$ brew install python3
Configurando PATH
Os programas e outros arquivos executáveis podem estar em vários diretórios, portanto, os sistemas operacionais fornecem um caminho de pesquisa que lista os diretórios em que o sistema operacional pesquisa executáveis.
O caminho é armazenado em uma variável de ambiente, que é uma string nomeada mantida pelo sistema operacional. Esta variável contém informações disponíveis para o shell de comando e outros programas.
A variável de caminho é nomeada como PATH no Unix ou Path no Windows (Unix diferencia maiúsculas de minúsculas; o Windows não).
No Mac OS, o instalador lida com os detalhes do caminho. Para invocar o interpretador Python de qualquer diretório específico, você deve adicionar o diretório Python ao seu caminho.
Configurando caminho em Unix / Linux
Para adicionar o diretório Python ao caminho para uma sessão particular no Unix -
No shell csh
Tipo setenv PATH "$PATH:/usr/local/bin/python" e pressione Enter.
No shell bash (Linux)
Tipo export ATH = "$PATH:/usr/local/bin/python" e pressione Enter.
No shell sh ou ksh
Tipo PATH = "$PATH:/usr/local/bin/python" e pressione Enter.
Note - / usr / local / bin / python é o caminho do diretório Python.
Configurando Caminho no Windows
Para adicionar o diretório Python ao caminho para uma sessão específica no Windows -
At the command prompt - tipo path %path%;C:\Python e pressione Enter.
Note - C: \ Python é o caminho do diretório Python.
Executando Python
Vamos agora ver as diferentes maneiras de executar Python. As formas são descritas abaixo -
Intérprete Interativo
Podemos iniciar o Python a partir do Unix, DOS ou qualquer outro sistema que forneça um interpretador de linha de comando ou janela de shell.
Entrar python na linha de comando.
Comece a codificar imediatamente no interpretador interativo.
$python # Unix/Linux
ou
python% # Unix/Linux
ou
C:> python # Windows/DOS
Aqui está a lista de todas as opções de linha de comando disponíveis -
S.No. | Opção e descrição |
---|---|
1 | -d Ele fornece saída de depuração. |
2 | -o Ele gera bytecode otimizado (resultando em arquivos .pyo). |
3 | -S Não execute o site de importação para procurar caminhos Python na inicialização. |
4 | -v Saída detalhada (rastreamento detalhado nas declarações de importação). |
5 | -x Desabilita exceções internas baseadas em classe (apenas use strings); obsoleto a partir da versão 1.6. |
6 | -c cmd Executa o script Python enviado como string cmd. |
7 | File Execute o script Python a partir do arquivo fornecido. |
Script da linha de comando
Um script Python pode ser executado na linha de comando invocando o interpretador em seu aplicativo, como a seguir -
$python script.py # Unix/Linux
ou,
python% script.py # Unix/Linux
ou,
C:> python script.py # Windows/DOS
Note - Certifique-se de que o modo de permissão de arquivo permite a execução.
Ambiente de desenvolvimento integrado
Você também pode executar o Python a partir de um ambiente de interface gráfica do usuário (GUI), se tiver um aplicativo GUI em seu sistema que suporte Python.
Unix - IDLE é o primeiro IDE Unix para Python.
Windows - PythonWin é a primeira interface do Windows para Python e é um IDE com uma GUI.
Macintosh - A versão do Python para Macintosh junto com o IDLE IDE está disponível no site principal, para download como arquivos MacBinary ou BinHex.
Se não conseguir configurar o ambiente adequadamente, você pode pedir ajuda ao administrador do sistema. Certifique-se de que o ambiente Python esteja configurado corretamente e funcionando perfeitamente bem.
Também podemos usar outra plataforma Python chamada Anaconda. Inclui centenas de pacotes populares de ciência de dados e o pacote conda e gerenciador de ambiente virtual para Windows, Linux e MacOS. Você pode baixá-lo de acordo com seu sistema operacional no linkhttps://www.anaconda.com/download/.
Para este tutorial, estamos usando a versão Python 3.6.3 no MS Windows.
Aprender significa a aquisição de conhecimentos ou habilidades por meio do estudo ou da experiência. Com base nisso, podemos definir o aprendizado de máquina (ML) da seguinte maneira -
Pode ser definida como o campo da ciência da computação, mais especificamente uma aplicação de inteligência artificial, que fornece aos sistemas de computador a capacidade de aprender com dados e melhorar com a experiência sem serem explicitamente programados.
Basicamente, o foco principal do aprendizado de máquina é permitir que os computadores aprendam automaticamente sem intervenção humana. Agora surge a pergunta: como esse aprendizado pode ser iniciado e feito? Pode ser iniciado com as observações dos dados. Os dados podem ser alguns exemplos, instruções ou algumas experiências diretas também. Então, com base nessa entrada, a máquina toma a melhor decisão procurando alguns padrões nos dados.
Tipos de aprendizado de máquina (ML)
Os Algoritmos de Aprendizado de Máquina ajudam o sistema de computador a aprender sem ser explicitamente programado. Esses algoritmos são categorizados em supervisionados ou não supervisionados. Vamos agora ver alguns algoritmos -
Algoritmos de aprendizado de máquina supervisionados
Este é o algoritmo de aprendizado de máquina mais comumente usado. É chamado supervisionado porque o processo de aprendizagem do algoritmo a partir do conjunto de dados de treinamento pode ser pensado como um professor supervisionando o processo de aprendizagem. Nesse tipo de algoritmo de ML, os resultados possíveis já são conhecidos e os dados de treinamento também são rotulados com as respostas corretas. Pode ser entendido da seguinte forma -
Suponha que temos variáveis de entrada x e uma variável de saída y e aplicamos um algoritmo para aprender a função de mapeamento da entrada para a saída, como -
Y = f(x)
Agora, o objetivo principal é aproximar a função de mapeamento tão bem que, quando tivermos novos dados de entrada (x), possamos prever a variável de saída (Y) para esses dados.
Problemas de aprendizagem supervisionados principalmente podem ser divididos nos seguintes dois tipos de problemas -
Classification - Um problema é chamado de problema de classificação quando temos a saída categorizada como “preto”, “ensino”, “não ensino”, etc.
Regression - Um problema é chamado de problema de regressão quando temos a saída de valor real, como "distância", "quilograma", etc.
Árvore de decisão, floresta aleatória, knn, regressão logística são exemplos de algoritmos de aprendizado de máquina supervisionado.
Algoritmos de aprendizado de máquina não supervisionados
Como o nome sugere, esses tipos de algoritmos de aprendizado de máquina não têm nenhum supervisor para fornecer qualquer tipo de orientação. É por isso que algoritmos de aprendizado de máquina não supervisionados estão intimamente alinhados com o que alguns chamam de verdadeira inteligência artificial. Pode ser entendido da seguinte forma -
Suponha que temos a variável de entrada x, então não haverá variáveis de saída correspondentes como há nos algoritmos de aprendizado supervisionado.
Em palavras simples, podemos dizer que na aprendizagem não supervisionada não haverá resposta correta e nenhum professor para a orientação. Algoritmos ajudam a descobrir padrões interessantes nos dados.
Os problemas de aprendizagem não supervisionados podem ser divididos nos seguintes dois tipos de problema -
Clustering- Em problemas de cluster, precisamos descobrir os agrupamentos inerentes aos dados. Por exemplo, agrupar clientes por seu comportamento de compra.
Association- Um problema é chamado de problema de associação porque esses tipos de problema requerem a descoberta das regras que descrevem grandes porções de nossos dados. Por exemplo, encontrar os clientes que compram ambosx e y.
K-means para clustering, algoritmo Apriori para associação são exemplos de algoritmos de aprendizado de máquina não supervisionados.
Algoritmos de aprendizado de máquina de reforço
Esses tipos de algoritmos de aprendizado de máquina são usados muito menos. Esses algoritmos treinam os sistemas para tomar decisões específicas. Basicamente, a máquina é exposta a um ambiente onde se treina continuamente usando o método de tentativa e erro. Esses algoritmos aprendem com a experiência anterior e tentam capturar o melhor conhecimento possível para tomar decisões precisas. O Processo de Decisão de Markov é um exemplo de algoritmos de aprendizado de máquina de reforço.
Algoritmos de aprendizado de máquina mais comuns
Nesta seção, aprenderemos sobre os algoritmos de aprendizado de máquina mais comuns. Os algoritmos são descritos abaixo -
Regressão linear
É um dos algoritmos mais conhecidos em estatística e aprendizado de máquina.
Conceito básico - Regressão linear principalmente é um modelo linear que assume uma relação linear entre as variáveis de entrada, digamos x, e a única variável de saída, digamos y. Em outras palavras, podemos dizer que y pode ser calculado a partir de uma combinação linear das variáveis de entrada x. A relação entre as variáveis pode ser estabelecida ajustando a melhor linha.
Tipos de regressão linear
A regressão linear é dos seguintes dois tipos -
Simple linear regression - Um algoritmo de regressão linear é chamado de regressão linear simples se tiver apenas uma variável independente.
Multiple linear regression - Um algoritmo de regressão linear é chamado de regressão linear múltipla se tiver mais de uma variável independente.
A regressão linear é usada principalmente para estimar os valores reais com base em variável (s) contínua (s). Por exemplo, a venda total de uma loja em um dia, com base em valores reais, pode ser estimada por regressão linear.
Regressão Logística
É um algoritmo de classificação e também conhecido como logit regressão.
Principalmente a regressão logística é um algoritmo de classificação que é usado para estimar os valores discretos como 0 ou 1, verdadeiro ou falso, sim ou não com base em um determinado conjunto de variáveis independentes. Basicamente, ele prevê a probabilidade, portanto, sua saída está entre 0 e 1.
Árvore de Decisão
A árvore de decisão é um algoritmo de aprendizado supervisionado usado principalmente para problemas de classificação.
Basicamente, é um classificador expresso como partição recursiva com base nas variáveis independentes. A árvore de decisão possui nós que formam a árvore com raiz. A árvore enraizada é uma árvore direcionada com um nó denominado “raiz”. Root não tem nenhuma borda de entrada e todos os outros nós têm uma borda de entrada. Esses nós são chamados de folhas ou nós de decisão. Por exemplo, considere a seguinte árvore de decisão para ver se uma pessoa é adequada ou não.
Máquina de vetor de suporte (SVM)
É usado para problemas de classificação e regressão. Mas, principalmente, é usado para problemas de classificação. O conceito principal do SVM é plotar cada item de dados como um ponto no espaço n-dimensional com o valor de cada recurso sendo o valor de uma coordenada específica. Aqui n seriam os recursos que teríamos. A seguir está uma representação gráfica simples para entender o conceito de SVM -
No diagrama acima, temos dois recursos, portanto, primeiro precisamos representar graficamente essas duas variáveis em um espaço bidimensional onde cada ponto tem duas coordenadas, chamadas de vetores de suporte. A linha divide os dados em dois grupos classificados diferentes. Essa linha seria o classificador.
Baías ingénuas
É também uma técnica de classificação. A lógica por trás dessa técnica de classificação é usar o teorema de Bayes para construir classificadores. O pressuposto é que os preditores são independentes. Em palavras simples, ele assume que a presença de um determinado recurso em uma classe não está relacionada à presença de qualquer outro recurso. Abaixo está a equação para o teorema de Bayes -
$$ P \ left (\ frac {A} {B} \ right) = \ frac {P \ left (\ frac {B} {A} \ right) P \ left (A \ right)} {P \ left ( B \ direita)} $$
O modelo Naïve Bayes é fácil de construir e particularmente útil para grandes conjuntos de dados.
K-vizinhos mais próximos (KNN)
É usado para classificação e regressão dos problemas. É amplamente utilizado para resolver problemas de classificação. O principal conceito desse algoritmo é que ele costuma armazenar todos os casos disponíveis e classificar os novos casos por maioria de votos de seus k vizinhos. O caso sendo então atribuído à classe que é a mais comum entre seus K-vizinhos mais próximos, medida por uma função de distância. A função de distância pode ser distância Euclidiana, Minkowski e distância de Hamming. Considere o seguinte para usar KNN -
Computacionalmente KNN são caros do que outros algoritmos usados para problemas de classificação.
A normalização das variáveis necessárias, caso contrário, as variáveis de faixa mais alta podem enviesá-lo.
No KNN, precisamos trabalhar no estágio de pré-processamento, como a remoção de ruído.
Clustering K-Means
Como o nome sugere, ele é usado para resolver os problemas de clustering. É basicamente um tipo de aprendizagem não supervisionada. A lógica principal do algoritmo de agrupamento K-Means é classificar o conjunto de dados por meio de vários clusters. Siga estas etapas para formar clusters por K-means -
K-means escolhe k número de pontos para cada cluster conhecido como centróides.
Agora, cada ponto de dados forma um cluster com os centróides mais próximos, ou seja, k clusters.
Agora, ele encontrará os centróides de cada cluster com base nos membros do cluster existentes.
Precisamos repetir essas etapas até que ocorra a convergência.
Floresta Aleatória
É um algoritmo de classificação supervisionado. A vantagem do algoritmo de floresta aleatória é que ele pode ser usado tanto para problemas de classificação quanto de regressão. Basicamente, é a coleção de árvores de decisão (ou seja, floresta) ou você pode dizer o conjunto das árvores de decisão. O conceito básico de floresta aleatória é que cada árvore dá uma classificação e a floresta escolhe as melhores classificações entre elas. A seguir estão as vantagens do algoritmo Random Forest -
O classificador de floresta aleatório pode ser usado para tarefas de classificação e regressão.
Eles podem lidar com os valores ausentes.
Ele não se ajustará ao modelo, mesmo que tenhamos mais árvores na floresta.
Já estudamos algoritmos de aprendizado de máquina supervisionados e não supervisionados. Esses algoritmos requerem dados formatados para iniciar o processo de treinamento. Devemos preparar ou formatar os dados de uma determinada maneira para que possam ser fornecidos como uma entrada para algoritmos de ML.
Este capítulo enfoca a preparação de dados para algoritmos de aprendizado de máquina.
Pré-processamento dos dados
Em nossa vida diária, lidamos com muitos dados, mas esses dados estão na forma bruta. Para fornecer os dados como entrada de algoritmos de aprendizado de máquina, precisamos convertê-los em dados significativos. É aí que o pré-processamento de dados entra em cena. Em outras palavras simples, podemos dizer que antes de fornecer os dados aos algoritmos de aprendizado de máquina, precisamos pré-processar os dados.
Etapas de pré-processamento de dados
Siga estas etapas para pré-processar os dados em Python -
Step 1 − Importing the useful packages - Se estivermos usando Python, então este seria o primeiro passo para converter os dados em um determinado formato, ou seja, pré-processamento. Isso pode ser feito da seguinte forma -
import numpy as np
import sklearn.preprocessing
Aqui, usamos os dois pacotes a seguir -
NumPy - Basicamente, NumPy é um pacote de processamento de array de propósito geral projetado para manipular eficientemente grandes arrays multi-dimensionais de registros arbitrários sem sacrificar muita velocidade para pequenos arrays multi-dimensionais.
Sklearn.preprocessing - Este pacote fornece muitas funções de utilitário comuns e classes de transformador para alterar vetores de recursos brutos em uma representação que seja mais adequada para algoritmos de aprendizado de máquina.
Step 2 − Defining sample data - Depois de importar os pacotes, precisamos definir alguns dados de amostra para que possamos aplicar técnicas de pré-processamento nesses dados. Vamos agora definir os seguintes dados de amostra -
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])
Step3 − Applying preprocessing technique - Nesta etapa, precisamos aplicar qualquer uma das técnicas de pré-processamento.
A seção a seguir descreve as técnicas de pré-processamento de dados.
Técnicas de pré-processamento de dados
As técnicas de pré-processamento de dados são descritas abaixo -
Binarização
Esta é a técnica de pré-processamento que é usada quando precisamos converter nossos valores numéricos em valores booleanos. Podemos usar um método embutido para binarizar os dados de entrada, digamos, usando 0,5 como o valor limite da seguinte maneira -
data_binarized = preprocessing.Binarizer(threshold = 0.5).transform(input_data)
print("\nBinarized data:\n", data_binarized)
Agora, depois de executar o código acima, obteremos a seguinte saída, todos os valores acima de 0,5 (valor limite) seriam convertidos para 1 e todos os valores abaixo de 0,5 seriam convertidos para 0.
Binarized data
[[ 1. 0. 1.]
[ 0. 1. 1.]
[ 0. 0. 1.]
[ 1. 1. 0.]]
Remoção Média
É outra técnica de pré-processamento muito comum usada no aprendizado de máquina. Basicamente, ele é usado para eliminar a média do vetor de recurso de forma que cada recurso seja centralizado em zero. Também podemos remover a polarização dos recursos no vetor de recursos. Para aplicar a técnica de pré-processamento de remoção média nos dados de amostra, podemos escrever o código Python mostrado abaixo. O código exibirá a média e o desvio padrão dos dados de entrada -
print("Mean = ", input_data.mean(axis = 0))
print("Std deviation = ", input_data.std(axis = 0))
Obteremos a seguinte saída após executar as linhas de código acima -
Mean = [ 1.75 -1.275 2.2]
Std deviation = [ 2.71431391 4.20022321 4.69414529]
Agora, o código a seguir removerá a média e o desvio padrão dos dados de entrada -
data_scaled = preprocessing.scale(input_data)
print("Mean =", data_scaled.mean(axis=0))
print("Std deviation =", data_scaled.std(axis = 0))
Obteremos a seguinte saída após executar as linhas de código acima -
Mean = [ 1.11022302e-16 0.00000000e+00 0.00000000e+00]
Std deviation = [ 1. 1. 1.]
Dimensionamento
É outra técnica de pré-processamento de dados usada para dimensionar os vetores de recursos. O dimensionamento dos vetores de recursos é necessário porque os valores de cada recurso podem variar entre muitos valores aleatórios. Em outras palavras, podemos dizer que o dimensionamento é importante porque não queremos que nenhum recurso seja sinteticamente grande ou pequeno. Com a ajuda do seguinte código Python, podemos fazer o escalonamento de nossos dados de entrada, ou seja, vetor de recurso -
# Min max scaling
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)
Obteremos a seguinte saída após executar as linhas de código acima -
Min max scaled data
[ [ 0.48648649 0.58252427 0.99122807]
[ 0. 1. 0.81578947]
[ 0.27027027 0. 1. ]
[ 1. 0. 99029126 0. ]]
Normalização
É outra técnica de pré-processamento de dados usada para modificar os vetores de recursos. Esse tipo de modificação é necessária para medir os vetores de características em uma escala comum. A seguir estão dois tipos de normalização que podem ser usados no aprendizado de máquina -
L1 Normalization
Também é conhecido como Least Absolute Deviations. Este tipo de normalização modifica os valores para que a soma dos valores absolutos seja sempre até 1 em cada linha. Ele pode ser implementado nos dados de entrada com a ajuda do seguinte código Python -
# Normalize data
data_normalized_l1 = preprocessing.normalize(input_data, norm = 'l1')
print("\nL1 normalized data:\n", data_normalized_l1)
A linha de código acima gera o seguinte 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]]
L2 Normalization
Também é conhecido como least squares. Este tipo de normalização modifica os valores para que a soma dos quadrados seja sempre até 1 em cada linha. Ele pode ser implementado nos dados de entrada com a ajuda do seguinte código Python -
# Normalize data
data_normalized_l2 = preprocessing.normalize(input_data, norm = 'l2')
print("\nL2 normalized data:\n", data_normalized_l2)
A linha de código acima irá gerar a seguinte saída -
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 ]]
Rotulando os dados
Já sabemos que dados em um determinado formato são necessários para algoritmos de aprendizado de máquina. Outro requisito importante é que os dados devem ser rotulados corretamente antes de serem enviados como entrada de algoritmos de aprendizado de máquina. Por exemplo, se falamos sobre classificação, há muitos rótulos nos dados. Esses rótulos estão na forma de palavras, números, etc. Funções relacionadas ao aprendizado de máquina emsklearnespere que os dados tenham rótulos numéricos. Portanto, se os dados estiverem em outra forma, eles devem ser convertidos em números. Este processo de transformar os rótulos das palavras em forma numérica é chamado de codificação de rótulos.
Etapas de codificação de rótulo
Siga estas etapas para codificar os rótulos de dados em Python -
Step1 − Importing the useful packages
Se estivermos usando Python, então este seria o primeiro passo para converter os dados em determinado formato, ou seja, pré-processamento. Isso pode ser feito da seguinte forma -
import numpy as np
from sklearn import preprocessing
Step 2 − Defining sample labels
Depois de importar os pacotes, precisamos definir alguns rótulos de amostra para que possamos criar e treinar o codificador de rótulos. Agora definiremos os seguintes rótulos de amostra -
# Sample input labels
input_labels = ['red','black','red','green','black','yellow','white']
Step 3 − Creating & training of label encoder object
Nesta etapa, precisamos criar o codificador de rótulo e treiná-lo. O código Python a seguir ajudará nisso -
# Creating the label encoder
encoder = preprocessing.LabelEncoder()
encoder.fit(input_labels)
A seguir está o resultado após a execução do código Python acima -
LabelEncoder()
Step4 − Checking the performance by encoding random ordered list
Esta etapa pode ser usada para verificar o desempenho, codificando a lista ordenada aleatória. O seguinte código Python pode ser escrito para fazer o mesmo -
# encoding a set of labels
test_labels = ['green','red','black']
encoded_values = encoder.transform(test_labels)
print("\nLabels =", test_labels)
As etiquetas seriam impressas da seguinte forma -
Labels = ['green', 'red', 'black']
Agora, podemos obter a lista de valores codificados, ou seja, rótulos de palavras convertidos em números da seguinte forma -
print("Encoded values =", list(encoded_values))
Os valores codificados seriam impressos da seguinte forma -
Encoded values = [1, 2, 0]
Step 5 − Checking the performance by decoding a random set of numbers −
Esta etapa pode ser usada para verificar o desempenho, decodificando o conjunto aleatório de números. O seguinte código Python pode ser escrito para fazer o mesmo -
# decoding a set of values
encoded_values = [3,0,4,1]
decoded_list = encoder.inverse_transform(encoded_values)
print("\nEncoded values =", encoded_values)
Agora, os valores codificados seriam impressos da seguinte forma -
Encoded values = [3, 0, 4, 1]
print("\nDecoded labels =", list(decoded_list))
Agora, os valores decodificados seriam impressos da seguinte forma -
Decoded labels = ['white', 'black', 'yellow', 'green']
Dados rotulados v / s não rotulados
Os dados não rotulados consistem principalmente em amostras de objetos naturais ou criados pelo homem que podem ser facilmente obtidos no mundo. Eles incluem áudio, vídeo, fotos, artigos de notícias, etc.
Por outro lado, os dados rotulados pegam um conjunto de dados não rotulados e aumentam cada parte desses dados não rotulados com alguma tag ou rótulo ou classe que seja significativa. Por exemplo, se temos uma foto, então o rótulo pode ser colocado com base no conteúdo da foto, ou seja, é a foto de um menino ou menina ou animal ou qualquer outra coisa. A rotulagem dos dados requer perícia humana ou julgamento sobre um dado dado não rotulado.
Existem muitos cenários onde os dados não rotulados são abundantes e facilmente obtidos, mas os dados rotulados geralmente requerem um humano / especialista para fazer anotações. O aprendizado semissupervisionado tenta combinar dados rotulados e não rotulados para construir modelos melhores.
Neste capítulo, vamos nos concentrar na implementação da aprendizagem supervisionada - classificação.
A técnica ou modelo de classificação tenta obter alguma conclusão a partir dos valores observados. No problema de classificação, temos a saída categorizada como “Preto” ou “branco” ou “Ensino” e “Não Ensino”. Ao construir o modelo de classificação, precisamos ter um conjunto de dados de treinamento que contenha pontos de dados e os rótulos correspondentes. Por exemplo, se queremos verificar se a imagem é de um carro ou não. Para verificar isso, construiremos um conjunto de dados de treinamento tendo as duas classes relacionadas a “carro” e “sem carro”. Em seguida, precisamos treinar o modelo usando os exemplos de treinamento. Os modelos de classificação são usados principalmente em reconhecimento facial, identificação de spam, etc.
Etapas para construir um classificador em Python
Para construir um classificador em Python, vamos usar Python 3 e Scikit-learn, que é uma ferramenta para aprendizado de máquina. Siga estas etapas para construir um classificador em Python -
Etapa 1 - Importar Scikit-learn
Este seria o primeiro passo para construir um classificador em Python. Nesta etapa, instalaremos um pacote Python chamado Scikit-learn, que é um dos melhores módulos de aprendizado de máquina em Python. O seguinte comando nos ajudará a importar o pacote -
Import Sklearn
Etapa 2 - importar o conjunto de dados do Scikit-learn
Nesta etapa, podemos começar a trabalhar com o conjunto de dados para nosso modelo de aprendizado de máquina. Aqui, vamos usarthe Breast Cancer Wisconsin Diagnostic Database. O conjunto de dados inclui várias informações sobre tumores de câncer de mama, bem como rótulos de classificação demalignant ou benign. O conjunto de dados tem 569 instâncias, ou dados, em 569 tumores e inclui informações sobre 30 atributos ou recursos, como o raio do tumor, textura, suavidade e área. Com a ajuda do seguinte comando, podemos importar o conjunto de dados de câncer de mama do Scikit-learn -
from sklearn.datasets import load_breast_cancer
Agora, o seguinte comando carregará o conjunto de dados.
data = load_breast_cancer()
A seguir está uma lista de chaves de dicionário importantes -
- Nomes de rótulos de classificação (target_names)
- Os rótulos reais (alvo)
- Os nomes de atributos / recursos (feature_names)
- O atributo (dados)
Agora, com a ajuda do seguinte comando, podemos criar novas variáveis para cada conjunto importante de informações e atribuir os dados. Em outras palavras, podemos organizar os dados com os seguintes comandos -
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']
Agora, para deixar mais claro, podemos imprimir os rótulos da classe, o rótulo da primeira instância de dados, nossos nomes de recursos e o valor do recurso com a ajuda dos seguintes comandos -
print(label_names)
O comando acima imprimirá os nomes das classes que são malignas e benignas, respectivamente. É mostrado como a saída abaixo -
['malignant' 'benign']
Agora, o comando abaixo mostrará que eles são mapeados para valores binários 0 e 1. Aqui, 0 representa o câncer maligno e 1 representa o câncer benigno. Você receberá a seguinte saída -
print(labels[0])
0
Os dois comandos fornecidos a seguir produzirão os nomes e valores dos recursos.
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]
Pela saída acima, podemos ver que a primeira instância de dados é um tumor maligno, cujo raio é 1.7990000e + 01.
Etapa 3 - Organização de dados em conjuntos
Nesta etapa, dividiremos nossos dados em duas partes, a saber, um conjunto de treinamento e um conjunto de teste. Dividir os dados nesses conjuntos é muito importante porque temos que testar nosso modelo nos dados não vistos. Para dividir os dados em conjuntos, sklearn tem uma função chamada detrain_test_split()função. Com a ajuda dos comandos a seguir, podemos dividir os dados nesses conjuntos -
from sklearn.model_selection import train_test_split
O comando acima irá importar o train_test_splitfunção do sklearn e o comando abaixo dividirá os dados em dados de treinamento e teste. No exemplo abaixo, estamos usando 40% dos dados para teste e os dados restantes seriam usados para treinar o modelo.
train, test, train_labels, test_labels = train_test_split(features,labels,test_size = 0.40, random_state = 42)
Etapa 4 - Construindo o modelo
Nesta etapa, estaremos construindo nosso modelo. Vamos usar o algoritmo Naïve Bayes para construir o modelo. Os seguintes comandos podem ser usados para construir o modelo -
from sklearn.naive_bayes import GaussianNB
O comando acima importará o módulo GaussianNB. Agora, o comando a seguir o ajudará a inicializar o modelo.
gnb = GaussianNB()
Vamos treinar o modelo ajustando-o aos dados usando gnb.fit ().
model = gnb.fit(train, train_labels)
Etapa 5 - Avaliação do modelo e sua precisão
Nesta etapa, vamos avaliar o modelo fazendo previsões em nossos dados de teste. Então, descobriremos sua precisão também. Para fazer previsões, usaremos a função predict (). O seguinte comando irá ajudá-lo a fazer isso -
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]
As séries de 0s e 1s acima são os valores previstos para as classes de tumor - maligno e benigno.
Agora, comparando as duas matrizes, a saber test_labels e preds, podemos descobrir a precisão do nosso modelo. Vamos usar oaccuracy_score()função para determinar a precisão. Considere o seguinte comando para isso -
from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965
O resultado mostra que o classificador NaïveBayes tem 95,17% de precisão.
Desta forma, com a ajuda das etapas acima, podemos construir nosso classificador em Python.
Classificador de construção em Python
Nesta seção, aprenderemos como construir um classificador em Python.
Classificador Naïve Bayes
Naïve Bayes é uma técnica de classificação usada para construir classificadores usando o teorema de Bayes. O pressuposto é que os preditores são independentes. Em palavras simples, ele assume que a presença de um determinado recurso em uma classe não está relacionada à presença de qualquer outro recurso. Para construir o classificador Naïve Bayes, precisamos usar a biblioteca python chamada scikit learn. Existem três tipos de modelos Naïve Bayes chamadosGaussian, Multinomial and Bernoulli no pacote de aprendizado do scikit.
Para construir um modelo de classificador de aprendizado de máquina Naïve Bayes, precisamos do seguinte e menos
Conjunto de Dados
Usaremos o conjunto de dados denominado Breast Cancer Wisconsin Diagnostic Database. O conjunto de dados inclui várias informações sobre tumores de câncer de mama, bem como rótulos de classificação demalignant ou benign. O conjunto de dados tem 569 instâncias, ou dados, em 569 tumores e inclui informações sobre 30 atributos ou recursos, como o raio do tumor, textura, suavidade e área. Podemos importar este conjunto de dados do pacote sklearn.
Modelo Naïve Bayes
Para construir o classificador Naïve Bayes, precisamos de um modelo Naïve Bayes. Como dito anteriormente, existem três tipos de modelos Naïve Bayes chamadosGaussian, Multinomial e Bernoullino pacote de aprendizado do scikit. Aqui, no exemplo a seguir, vamos usar o modelo Gaussian Naïve Bayes.
Usando o acima, vamos construir um modelo de aprendizado de máquina Naïve Bayes para usar as informações do tumor para prever se um tumor é maligno ou benigno.
Para começar, precisamos instalar o módulo sklearn. Isso pode ser feito com a ajuda do seguinte comando -
Import Sklearn
Agora, precisamos importar o conjunto de dados denominado Breast Cancer Wisconsin Diagnostic Database.
from sklearn.datasets import load_breast_cancer
Agora, o seguinte comando carregará o conjunto de dados.
data = load_breast_cancer()
Os dados podem ser organizados da seguinte forma -
label_names = data['target_names']
labels = data['target']
feature_names = data['feature_names']
features = data['data']
Agora, para deixar mais claro, podemos imprimir os rótulos da classe, o rótulo da primeira instância de dados, nossos nomes de recursos e o valor do recurso com a ajuda dos seguintes comandos -
print(label_names)
O comando acima imprimirá os nomes das classes que são malignas e benignas, respectivamente. É mostrado como a saída abaixo -
['malignant' 'benign']
Agora, o comando fornecido a seguir mostrará que eles são mapeados para valores binários 0 e 1. Aqui, 0 representa o câncer maligno e 1 representa o câncer benigno. É mostrado como a saída abaixo -
print(labels[0])
0
Os dois comandos a seguir produzirão os nomes e valores dos recursos.
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]
Pela saída acima, podemos ver que a primeira instância de dados é um tumor maligno, cujo raio principal é 1.7990000e + 01.
Para testar nosso modelo em dados não vistos, precisamos dividir nossos dados em dados de treinamento e teste. Isso pode ser feito com a ajuda do seguinte código -
from sklearn.model_selection import train_test_split
O comando acima irá importar o train_test_splitfunção do sklearn e o comando abaixo dividirá os dados em dados de treinamento e teste. No exemplo abaixo, estamos usando 40% dos dados para teste e os dados remanescentes seriam usados para treinar o modelo.
train, test, train_labels, test_labels =
train_test_split(features,labels,test_size = 0.40, random_state = 42)
Agora, estamos construindo o modelo com os seguintes comandos -
from sklearn.naive_bayes import GaussianNB
O comando acima irá importar o GaussianNBmódulo. Agora, com o comando fornecido a seguir, precisamos inicializar o modelo.
gnb = GaussianNB()
Vamos treinar o modelo ajustando-o aos dados usando gnb.fit().
model = gnb.fit(train, train_labels)
Agora, avalie o modelo fazendo previsões sobre os dados de teste e isso pode ser feito da seguinte maneira -
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]
A série acima de 0s e 1s são os valores previstos para as classes de tumor, ou seja, maligno e benigno.
Agora, comparando as duas matrizes, a saber test_labels e preds, podemos descobrir a precisão do nosso modelo. Vamos usar oaccuracy_score()função para determinar a precisão. Considere o seguinte comando -
from sklearn.metrics import accuracy_score
print(accuracy_score(test_labels,preds))
0.951754385965
O resultado mostra que o classificador NaïveBayes tem 95,17% de precisão.
Esse foi o classificador de aprendizado de máquina baseado no modelo Naïve Bayse Gaussian.
Support Vector Machines (SVM)
Basicamente, a máquina de vetores de suporte (SVM) é um algoritmo de aprendizado de máquina supervisionado que pode ser usado para regressão e classificação. O conceito principal do SVM é plotar cada item de dados como um ponto no espaço n-dimensional com o valor de cada recurso sendo o valor de uma coordenada específica. Aqui n seriam os recursos que teríamos. A seguir está uma representação gráfica simples para entender o conceito de SVM -
No diagrama acima, temos dois recursos. Portanto, primeiro precisamos representar graficamente essas duas variáveis em um espaço bidimensional onde cada ponto tem duas coordenadas, chamadas de vetores de suporte. A linha divide os dados em dois grupos classificados diferentes. Essa linha seria o classificador.
Aqui, vamos construir um classificador SVM usando o conjunto de dados scikit-learn e iris. A biblioteca Scikitlearn tem osklearn.svmmódulo e fornece sklearn.svm.svc para classificação. O classificador SVM para prever a classe da planta da íris com base em 4 recursos é mostrado abaixo.
Conjunto de Dados
Usaremos o conjunto de dados da íris que contém 3 classes de 50 instâncias cada, onde cada classe se refere a um tipo de planta da íris. Cada instância tem quatro características: comprimento e largura da sépala, comprimento e largura da pétala. O classificador SVM para prever a classe da planta da íris com base em 4 recursos é mostrado abaixo.
Núcleo
É uma técnica usada pelo SVM. Basicamente, essas são as funções que pegam o espaço de entrada de baixa dimensão e o transformam em um espaço de dimensão superior. Ele converte um problema não separável em um problema separável. A função do kernel pode ser qualquer uma entre linear, polinomial, rbf e sigmóide. Neste exemplo, usaremos o kernel linear.
Vamos agora importar os seguintes pacotes -
import pandas as pd
import numpy as np
from sklearn import svm, datasets
import matplotlib.pyplot as plt
Agora, carregue os dados de entrada -
iris = datasets.load_iris()
Estamos pegando os dois primeiros recursos -
X = iris.data[:, :2]
y = iris.target
Traçaremos os limites da máquina de vetores de suporte com os dados originais. Estamos criando uma malha para plotar.
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()]
Precisamos fornecer o valor do parâmetro de regularização.
C = 1.0
Precisamos criar o objeto classificador 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')
Regressão Logística
Basicamente, o modelo de regressão logística é um dos membros da família de algoritmos de classificação supervisionada. A regressão logística mede a relação entre as variáveis dependentes e as variáveis independentes, estimando as probabilidades usando uma função logística.
Aqui, se falamos sobre variáveis dependentes e independentes, então a variável dependente é a variável da classe-alvo que vamos prever e, por outro lado, as variáveis independentes são os recursos que vamos usar para prever a classe-alvo.
Na regressão logística, estimar as probabilidades significa prever a probabilidade de ocorrência do evento. Por exemplo, o dono da loja gostaria de prever que o cliente que entrou na loja comprará a play station (por exemplo) ou não. Haveria muitas características do cliente - sexo, idade, etc. que seriam observadas pelo lojista para prever a probabilidade de ocorrência, ou seja, comprar ou não uma play station. A função logística é a curva sigmóide que é usada para construir a função com vários parâmetros.
Pré-requisitos
Antes de construir o classificador usando regressão logística, precisamos instalar o pacote Tkinter em nosso sistema. Pode ser instalado a partir dehttps://docs.python.org/2/library/tkinter.html.
Agora, com a ajuda do código fornecido a seguir, podemos criar um classificador usando regressão logística -
Primeiro, vamos importar alguns pacotes -
import numpy as np
from sklearn import linear_model
import matplotlib.pyplot as plt
Agora, precisamos definir os dados de amostra, o que pode ser feito da seguinte maneira -
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])
Em seguida, precisamos criar o classificador de regressão logística, o que pode ser feito da seguinte maneira -
Classifier_LR = linear_model.LogisticRegression(solver = 'liblinear', C = 75)
Por último, mas não menos importante, precisamos treinar este classificador -
Classifier_LR.fit(X, y)
Agora, como podemos visualizar a saída? Isso pode ser feito criando uma função chamada 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
Na linha acima, definimos os valores mínimo e máximo de X e Y a serem usados na grade da malha. Além disso, definiremos o tamanho do passo para traçar a grade da malha.
mesh_step_size = 0.02
Vamos definir a grade de malha dos valores X e Y da seguinte forma -
x_vals, y_vals = np.meshgrid(np.arange(min_x, max_x, mesh_step_size),
np.arange(min_y, max_y, mesh_step_size))
Com a ajuda do código a seguir, podemos executar o classificador na grade de malha -
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)
A seguinte linha de código irá especificar os limites do gráfico
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()
Agora, depois de executar o código, obteremos a seguinte saída, classificador de regressão logística -
Classificador de árvore de decisão
Uma árvore de decisão é basicamente um fluxograma de árvore binária onde cada nó divide um grupo de observações de acordo com alguma variável de recurso.
Aqui, estamos construindo um classificador de árvore de decisão para prever homens ou mulheres. Vamos pegar um conjunto de dados muito pequeno com 19 amostras. Essas amostras consistiriam em duas características - 'altura' e 'comprimento do cabelo'.
Pré-requisito
Para construir o seguinte classificador, precisamos instalar pydotplus e graphviz. Basicamente, graphviz é uma ferramenta para desenhar gráficos usando arquivos de ponto epydotplusé um módulo para a linguagem Dot do Graphviz. Ele pode ser instalado com o gerenciador de pacotes ou pip.
Agora, podemos construir o classificador da árvore de decisão com a ajuda do seguinte código Python -
Para começar, vamos importar algumas bibliotecas importantes da seguinte maneira -
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
Agora, precisamos fornecer o conjunto de dados da seguinte forma -
X = [[165,19],[175,32],[136,35],[174,65],[141,28],[176,15],[131,32],
[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','Woman',
'Man','Woman','Man','Woman','Woman','Woman','Man','Woman','Woman','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)
Depois de fornecer o conjunto de dados, precisamos ajustar o modelo, o que pode ser feito da seguinte maneira -
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X,Y)
A previsão pode ser feita com a ajuda do seguinte código Python -
prediction = clf.predict([[133,37]])
print(prediction)
Podemos visualizar a árvore de decisão com a ajuda do seguinte código 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')
Ele dará a previsão para o código acima como [‘Woman’] e criar a seguinte árvore de decisão -
Podemos alterar os valores dos recursos na previsão para testá-lo.
Classificador Random Forest
Como sabemos, os métodos de ensemble são os métodos que combinam modelos de aprendizado de máquina em um modelo de aprendizado de máquina mais poderoso. Random Forest, uma coleção de árvores de decisão, é uma delas. É melhor do que uma árvore de decisão única porque, ao mesmo tempo que retém os poderes preditivos, pode reduzir o sobreajuste ao calcular a média dos resultados. Aqui, vamos implementar o modelo de floresta aleatório no conjunto de dados de câncer scikit learn.
Importe os pacotes necessários -
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
Agora, precisamos fornecer o conjunto de dados, o que pode ser feito da seguinte maneira e menos
cancer = load_breast_cancer()
X_train, X_test, y_train,
y_test = train_test_split(cancer.data, cancer.target, random_state = 0)
Depois de fornecer o conjunto de dados, precisamos ajustar o modelo, o que pode ser feito da seguinte maneira -
forest = RandomForestClassifier(n_estimators = 50, random_state = 0)
forest.fit(X_train,y_train)
Agora, obtenha a precisão do subconjunto de treinamento e de teste: se aumentarmos o número de estimadores, a precisão do subconjunto de teste também aumentará.
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)))
Resultado
Accuracy on the training subset:(:.3f) 1.0
Accuracy on the training subset:(:.3f) 0.965034965034965
Agora, como a árvore de decisão, a floresta aleatória tem o feature_importancemódulo que fornecerá uma visão melhor do peso do recurso do que a árvore de decisão. Pode ser traçado e visualizado da seguinte forma -
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()
Desempenho de um classificador
Depois de implementar um algoritmo de aprendizado de máquina, precisamos descobrir a eficácia do modelo. Os critérios para medir a eficácia podem ser baseados em conjuntos de dados e métricas. Para avaliar diferentes algoritmos de aprendizado de máquina, podemos usar diferentes métricas de desempenho. Por exemplo, suponha que se um classificador é usado para distinguir entre imagens de objetos diferentes, podemos usar as métricas de desempenho de classificação, como precisão média, AUC, etc. muito importante porque a escolha das métricas influencia como o desempenho de um algoritmo de aprendizado de máquina é medido e comparado. A seguir estão algumas das métricas -
Matriz de confusão
Basicamente, é usado para problemas de classificação onde a saída pode ser de dois ou mais tipos de classes. É a maneira mais fácil de medir o desempenho de um classificador. Uma matriz de confusão é basicamente uma tabela com duas dimensões, a saber, “Real” e “Previsto”. Ambas as dimensões têm “Verdadeiros positivos (TP)”, “Verdadeiros negativos (TN)”, “Falsos positivos (FP)”, “Falsos negativos (FN)”.
Na matriz de confusão acima, 1 é para classe positiva e 0 é para classe negativa.
A seguir estão os termos associados à matriz de confusão -
True Positives − TPs são os casos em que a classe real de ponto de dados era 1 e o previsto também é 1.
True Negatives − TNs são os casos em que a classe real do ponto de dados era 0 e o previsto também é 0.
False Positives − FPs são os casos em que a classe real do ponto de dados era 0 e o previsto também é 1.
False Negatives − FNs são os casos em que a classe real do ponto de dados era 1 e o previsto também é 0.
Precisão
A matriz de confusão em si não é uma medida de desempenho como tal, mas quase todas as matrizes de desempenho são baseadas na matriz de confusão. Um deles é a precisão. Em problemas de classificação, pode ser definido como o número de previsões corretas feitas pelo modelo sobre todos os tipos de previsões feitas. A fórmula para calcular a precisão é a seguinte -
$$ Precisão = \ frac {TP + TN} {TP + FP + FN + TN} $$
Precisão
É usado principalmente em recuperação de documentos. Pode ser definido como quantos dos documentos devolvidos estão corretos. A seguir está a fórmula para calcular a precisão -
$$ Precisão = \ frac {TP} {TP + FP} $$
Rechamada ou Sensibilidade
Pode ser definido como quantos pontos positivos o modelo retorna. A seguir está a fórmula para calcular o recall / sensibilidade do modelo -
$$ Rechamada = \ frac {TP} {TP + FN} $$
Especificidade
Pode ser definido como quantos negativos o modelo retorna. É exatamente o oposto de lembrar. A seguir está a fórmula para calcular a especificidade do modelo -
$$ Especificidade = \ frac {TN} {TN + FP} $$
Problema de desequilíbrio de classe
O desequilíbrio de classe é o cenário em que o número de observações pertencentes a uma classe é significativamente menor do que as pertencentes às outras classes. Por exemplo, este problema é proeminente no cenário em que precisamos identificar as doenças raras, transações fraudulentas em bancos etc.
Exemplo de classes desequilibradas
Vamos considerar um exemplo de conjunto de dados de detecção de fraude para entender o conceito de classe desequilibrada -
Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%
Solução
Balancing the classes’atua como uma solução para classes desequilibradas. O objetivo principal de equilibrar as classes é aumentar a frequência da classe minoritária ou diminuir a frequência da classe majoritária. A seguir estão as abordagens para resolver o problema das classes de desequilíbrios -
Re-amostragem
A reamostragem é uma série de métodos usados para reconstruir os conjuntos de dados de amostra - conjuntos de treinamento e conjuntos de teste. A reamostragem é feita para melhorar a precisão do modelo. A seguir estão algumas técnicas de reamostragem -
Random Under-Sampling- Esta técnica visa equilibrar a distribuição de classes eliminando aleatoriamente exemplos de classes majoritárias. Isso é feito até que as instâncias de classe majoritária e minoritária sejam equilibradas.
Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%
Neste caso, estamos pegando 10% das amostras sem substituição de instâncias não fraudulentas e, em seguida, combinamos com as instâncias de fraude -
Observações não fraudulentas após amostragem aleatória = 10% de 4950 = 495
Total de observações após combiná-las com observações fraudulentas = 50 + 495 = 545
Portanto, agora, a taxa de eventos para o novo conjunto de dados após sob amostragem = 9%
A principal vantagem dessa técnica é que ela pode reduzir o tempo de execução e melhorar o armazenamento. Mas, por outro lado, ele pode descartar informações úteis enquanto reduz o número de amostras de dados de treinamento.
Random Over-Sampling - Esta técnica visa equilibrar a distribuição de classes, aumentando o número de instâncias na classe minoritária, replicando-as.
Total observations = 5000
Fraudulent Observations = 50
Non-Fraudulent Observations = 4950
Event Rate = 1%
No caso de estarmos replicando 50 observações fraudulentas 30 vezes, as observações fraudulentas após replicar as observações da classe minoritária seriam 1500. E então o total de observações nos novos dados após a sobreamostragem seria 4950 + 1500 = 6450. Portanto, a taxa de eventos para o novo conjunto de dados seria 1500/6450 = 23%.
A principal vantagem desse método é que não haveria perda de informações úteis. Mas, por outro lado, tem maiores chances de sobreajuste porque replica os eventos da classe minoritária.
Técnicas de conjunto
Esta metodologia é usada basicamente para modificar algoritmos de classificação existentes para torná-los adequados para conjuntos de dados desequilibrados. Nesta abordagem, construímos vários classificadores de dois estágios a partir dos dados originais e, em seguida, agregamos suas previsões. O classificador de floresta aleatório é um exemplo de classificador baseado em conjunto.
A regressão é uma das ferramentas estatísticas e de aprendizado de máquina mais importantes. Não estaríamos errados em dizer que a jornada do aprendizado de máquina começa da regressão. Pode ser definido como a técnica paramétrica que nos permite tomar decisões com base em dados ou, em outras palavras, nos permite fazer previsões com base em dados, aprendendo a relação entre as variáveis de entrada e saída. Aqui, as variáveis de saída dependentes das variáveis de entrada são números reais de valor contínuo. Na regressão, a relação entre as variáveis de entrada e saída é importante e nos ajuda a entender como o valor da variável de saída muda com a mudança da variável de entrada. A regressão é freqüentemente usada para previsão de preços, economia, variações e assim por diante.
Construindo regressores em Python
Nesta seção, aprenderemos como construir um regressor único e também multivariável.
Regressor Linear / Regressor de Variável Única
Deixe-nos importantes alguns pacotes necessários -
import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt
Agora, precisamos fornecer os dados de entrada e salvamos nossos dados no arquivo denominado linear.txt.
input = 'D:/ProgramData/linear.txt'
Precisamos carregar esses dados usando o np.loadtxt função.
input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]
A próxima etapa seria treinar o modelo. Vamos dar amostras de treinamento e teste.
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:]
Agora, precisamos criar um objeto de regressor linear.
reg_linear = linear_model.LinearRegression()
Treine o objeto com os exemplos de treinamento.
reg_linear.fit(X_train, y_train)
Precisamos fazer a previsão com os dados de teste.
y_test_pred = reg_linear.predict(X_test)
Agora plote e visualize os dados.
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()
Resultado
Agora, podemos calcular o desempenho de nossa regressão linear da seguinte maneira -
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))
Resultado
Desempenho do regressor linear -
Mean absolute error = 1.78
Mean squared error = 3.89
Median absolute error = 2.01
Explain variance score = -0.09
R2 score = -0.09
No código acima, usamos esses pequenos dados. Se você quiser um grande conjunto de dados, pode usar sklearn.dataset para importar um conjunto de dados maior.
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
Regressor multivariável
Primeiro, vamos importar alguns pacotes necessários -
import numpy as np
from sklearn import linear_model
import sklearn.metrics as sm
import matplotlib.pyplot as plt
from sklearn.preprocessing import PolynomialFeatures
Agora, precisamos fornecer os dados de entrada e salvamos nossos dados no arquivo denominado linear.txt.
input = 'D:/ProgramData/Mul_linear.txt'
Vamos carregar esses dados usando o np.loadtxt função.
input_data = np.loadtxt(input, delimiter=',')
X, y = input_data[:, :-1], input_data[:, -1]
A próxima etapa seria treinar o modelo; nós daremos amostras de treinamento e teste.
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:]
Agora, precisamos criar um objeto de regressor linear.
reg_linear_mul = linear_model.LinearRegression()
Treine o objeto com os exemplos de treinamento.
reg_linear_mul.fit(X_train, y_train)
Agora, finalmente, precisamos fazer a previsão com os dados de teste.
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))
Resultado
Desempenho do regressor linear -
Mean absolute error = 0.6
Mean squared error = 0.65
Median absolute error = 0.41
Explain variance score = 0.34
R2 score = 0.33
Agora, vamos criar um polinômio de grau 10 e treinar o regressor. Forneceremos o ponto de dados de amostra.
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))
Resultado
Regressão linear -
[2.40170462]
Regressão polinomial -
[1.8697225]
No código acima, usamos esses pequenos dados. Se você quiser um grande conjunto de dados, pode usar sklearn.dataset para importar um conjunto de dados maior.
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
Neste capítulo, enfocaremos a programação lógica e como ela ajuda na Inteligência Artificial.
Já sabemos que a lógica é o estudo dos princípios do raciocínio correto ou, em palavras simples, é o estudo do que vem depois do quê. Por exemplo, se duas afirmações são verdadeiras, podemos inferir qualquer terceira afirmação a partir delas.
Conceito
A programação lógica é a combinação de duas palavras, lógica e programação. A Programação Lógica é um paradigma de programação no qual os problemas são expressos como fatos e regras por declarações de programa, mas dentro de um sistema de lógica formal. Assim como outros paradigmas de programação, como orientado a objetos, funcional, declarativo e procedural, etc., também é uma maneira particular de abordar a programação.
Como resolver problemas com programação lógica
A programação lógica usa fatos e regras para resolver o problema. É por isso que são chamados de blocos de construção da Programação Lógica. Uma meta precisa ser especificada para cada programa de programação lógica. Para entender como um problema pode ser resolvido na programação lógica, precisamos saber sobre os blocos de construção - Fatos e Regras -
Fatos
Na verdade, todo programa lógico precisa de fatos com os quais trabalhar, de modo que possa atingir o objetivo dado. Os fatos são basicamente afirmações verdadeiras sobre o programa e os dados. Por exemplo, Delhi é a capital da Índia.
Regras
Na verdade, as regras são as restrições que nos permitem tirar conclusões sobre o domínio do problema. Regras basicamente escritas como cláusulas lógicas para expressar vários fatos. Por exemplo, se estamos construindo qualquer jogo, todas as regras devem ser definidas.
As regras são muito importantes para resolver qualquer problema de programação em lógica. Regras são conclusões basicamente lógicas que podem expressar os fatos. A seguir está a sintaxe da regra -
A∶− B1, B2, ..., B n .
Aqui, A é a cabeça e B1, B2, ... Bn é o corpo.
Por exemplo - ancestral (X, Y): - pai (X, Y).
ancestral (X, Z): - pai (X, Y), ancestral (Y, Z).
Isso pode ser lido como, para cada X e Y, se X é o pai de Y e Y é um ancestral de Z, X é o ancestral de Z. Para cada X e Y, X é o ancestral de Z, se X for o pai de Y e Y é um ancestral de Z.
Instalando Pacotes Úteis
Para iniciar a programação lógica em Python, precisamos instalar os dois pacotes a seguir -
Kanren
Ele nos fornece uma maneira de simplificar a maneira como criamos código para lógica de negócios. Permite-nos expressar a lógica em termos de regras e fatos. O seguinte comando irá ajudá-lo a instalar o Kanren -
pip install kanren
SymPy
SymPy é uma biblioteca Python para matemática simbólica. O objetivo é se tornar um sistema de álgebra computacional (CAS) completo, enquanto mantém o código o mais simples possível para ser compreensível e facilmente extensível. O seguinte comando ajudará você a instalar o SymPy -
pip install sympy
Exemplos de programação lógica
A seguir estão alguns exemplos que podem ser resolvidos por programação lógica -
Expressões matemáticas correspondentes
Na verdade, podemos encontrar os valores desconhecidos usando a programação lógica de uma forma muito eficaz. O seguinte código Python ajudará você a encontrar uma expressão matemática -
Considere importar os seguintes pacotes primeiro -
from kanren import run, var, fact
from kanren.assoccomm import eq_assoccomm as eq
from kanren.assoccomm import commutative, associative
Precisamos definir as operações matemáticas que vamos usar -
add = 'add'
mul = 'mul'
Tanto a adição quanto a multiplicação são processos comunicativos. Portanto, precisamos especificá-lo e isso pode ser feito da seguinte forma -
fact(commutative, mul)
fact(commutative, add)
fact(associative, mul)
fact(associative, add)
É obrigatório definir variáveis; isso pode ser feito da seguinte maneira -
a, b = var('a'), var('b')
Precisamos combinar a expressão com o padrão original. Temos o seguinte padrão original, que é basicamente (5 + a) * b -
Original_pattern = (mul, (add, 5, a), b)
Temos as duas seguintes expressões para corresponder ao padrão original -
exp1 = (mul, 2, (add, 3, 1))
exp2 = (add,5,(mul,8,1))
A saída pode ser impressa com o seguinte comando -
print(run(0, (a,b), eq(original_pattern, exp1)))
print(run(0, (a,b), eq(original_pattern, exp2)))
Depois de executar este código, obteremos a seguinte saída -
((3,2))
()
A primeira saída representa os valores para a e b. A primeira expressão correspondeu ao padrão original e retornou os valores paraa e b mas a segunda expressão não correspondeu ao padrão original, portanto, nada foi retornado.
Verificando números primos
Com a ajuda da programação lógica, podemos encontrar os números primos em uma lista de números e também gerar números primos. O código Python fornecido a seguir encontrará o número primo em uma lista de números e também gerará os primeiros 10 números primos.
Vamos primeiro considerar a importação dos seguintes pacotes -
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
Agora, definiremos uma função chamada prime_check que verificará os números primos com base nos números fornecidos como dados.
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
Agora, precisamos declarar uma variável que será usada -
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))))
A saída do código acima será a seguinte -
{19, 23, 29, 41}
(2, 3, 5, 7, 11, 13, 17, 19, 23, 29)
Resolvendo quebra-cabeças
A programação lógica pode ser usada para resolver muitos problemas como quebra-cabeças de 8, quebra-cabeças de zebra, Sudoku, N-queen, etc. Aqui estamos tomando um exemplo de uma variante do quebra-cabeça de zebra que é o seguinte
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.
Estamos resolvendo para a questão who owns zebra com a ajuda de Python.
Deixe-nos importar os pacotes necessários -
from kanren import *
from kanren.core import lall
import time
Agora, precisamos definir duas funções - left() e next() para verificar de quem é a casa restante ou ao lado da casa de quem -
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)])
Agora, vamos declarar uma casa variável da seguinte forma -
houses = var()
Precisamos definir as regras com a ajuda do pacote lall como segue.
Existem 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)
)
Agora, execute o solucionador com as restrições anteriores -
solutions = run(0, houses, rules_zebraproblem)
Com a ajuda do código a seguir, podemos extrair a saída do solucionador -
output_zebra = [house for house in solutions[0] if 'zebra' in house][0][0]
O código a seguir ajudará a imprimir a solução -
print ('\n'+ output_zebra + 'owns zebra.')
A saída do código acima seria a seguinte -
German owns zebra.
Algoritmos de aprendizado de máquina não supervisionados não têm nenhum supervisor para fornecer qualquer tipo de orientação. É por isso que estão intimamente alinhados com o que alguns chamam de verdadeira inteligência artificial.
No aprendizado não supervisionado, não haveria resposta correta e nenhum professor para a orientação. Algoritmos precisam descobrir o padrão interessante de dados para aprendizagem.
O que é clustering?
Basicamente, é um tipo de método de aprendizagem não supervisionado e uma técnica comum para análise de dados estatísticos usada em muitos campos. O clustering é principalmente uma tarefa de dividir o conjunto de observações em subconjuntos, chamados clusters, de forma que as observações no mesmo cluster sejam semelhantes em um sentido e diferentes das observações em outros clusters. Em palavras simples, podemos dizer que o objetivo principal do agrupamento é agrupar os dados com base na similaridade e dissimilaridade.
Por exemplo, o diagrama a seguir mostra tipos semelhantes de dados em diferentes clusters -
Algoritmos para agrupar os dados
A seguir estão alguns algoritmos comuns para agrupar os dados -
Algoritmo K-Means
O algoritmo de agrupamento K-means é um dos algoritmos bem conhecidos para agrupar os dados. Precisamos assumir que o número de clusters já é conhecido. Isso também é chamado de clustering simples. É um algoritmo de agrupamento iterativo. As etapas fornecidas a seguir precisam ser seguidas para este algoritmo -
Step 1 - Precisamos especificar o número desejado de K subgrupos.
Step 2- Corrija o número de clusters e atribua aleatoriamente cada ponto de dados a um cluster. Ou em outras palavras, precisamos classificar nossos dados com base no número de clusters.
Nesta etapa, os centróides do cluster devem ser calculados.
Como este é um algoritmo iterativo, precisamos atualizar as localizações dos centróides K a cada iteração até encontrarmos os ótimos globais ou em outras palavras, os centróides alcançam suas localizações ideais.
O código a seguir ajudará na implementação do algoritmo de agrupamento K-means em Python. Vamos usar o módulo Scikit-learn.
Deixe-nos importar os pacotes necessários -
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
A linha de código a seguir ajudará na geração do conjunto de dados bidimensional, contendo quatro blobs, usando make_blob de sklearn.dataset pacote.
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 o conjunto de dados usando o seguinte código -
plt.scatter(X[:, 0], X[:, 1], s = 50);
plt.show()
Aqui, estamos inicializando kmeans para ser o algoritmo KMeans, com o parâmetro necessário de quantos clusters (n_clusters).
kmeans = KMeans(n_clusters = 4)
Precisamos treinar o modelo K-means com os dados 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_
O código fornecido a seguir nos ajudará a traçar e visualizar as descobertas da máquina com base em nossos dados e a montagem de acordo com o número de clusters que podem ser encontrados.
plt.scatter(centers[:, 0], centers[:, 1], c = 'black', s = 200, alpha = 0.5);
plt.show()
Algoritmo de deslocamento médio
É outro algoritmo de clustering popular e poderoso usado na aprendizagem não supervisionada. Não faz suposições, portanto, é um algoritmo não paramétrico. Também é chamado de agrupamento hierárquico ou análise de agrupamento de deslocamento médio. A seguir estão as etapas básicas deste algoritmo -
Em primeiro lugar, precisamos começar com os pontos de dados atribuídos a um cluster próprio.
Agora, ele calcula os centróides e atualiza a localização de novos centróides.
Ao repetir este processo, aproximamo-nos do pico do cluster, ou seja, em direção à região de maior densidade.
Este algoritmo para no estágio em que os centróides não se movem mais.
Com a ajuda do código a seguir, estamos implementando o algoritmo de agrupamento Mean Shift em Python. Vamos usar o módulo Scikit-learning.
Deixe-nos importar os pacotes necessários -
import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")
O código a seguir ajudará na geração do conjunto de dados bidimensional, contendo quatro blobs, usando make_blob de sklearn.dataset pacote.
from sklearn.datasets.samples_generator import make_blobs
Podemos visualizar o conjunto de dados com o seguinte 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()
Agora, precisamos treinar o modelo de cluster de deslocamento médio com os dados de entrada.
ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
O código a seguir imprimirá os centros de cluster e o número esperado de cluster de acordo com os dados 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
O código fornecido a seguir ajudará a traçar e visualizar as descobertas da máquina com base em nossos dados e o ajuste de acordo com o número de clusters que podem ser encontrados.
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()
Medindo o desempenho do clustering
Os dados do mundo real não são organizados naturalmente em vários grupos distintos. Por esse motivo, não é fácil visualizar e fazer inferências. É por isso que precisamos medir o desempenho do cluster, bem como sua qualidade. Isso pode ser feito com a ajuda da análise de silhueta.
Análise de Silhueta
Este método pode ser usado para verificar a qualidade do agrupamento medindo a distância entre os agrupamentos. Basicamente, ele fornece uma maneira de avaliar os parâmetros como o número de clusters, fornecendo uma pontuação de silhueta. Essa pontuação é uma métrica que mede a proximidade de cada ponto em um cluster dos pontos nos clusters vizinhos.
Análise da pontuação da silhueta
A pontuação tem um intervalo de [-1, 1]. A seguir está a análise dessa pontuação -
Score of +1 - Pontuação próxima de +1 indica que a amostra está longe do agrupamento vizinho.
Score of 0 - A pontuação 0 indica que a amostra está no ou muito perto do limite de decisão entre dois clusters vizinhos.
Score of -1 - A pontuação negativa indica que as amostras foram atribuídas aos clusters errados.
Calculando a pontuação da silhueta
Nesta seção, aprenderemos como calcular a pontuação da silhueta.
A pontuação da silhueta pode ser calculada usando a seguinte fórmula -
$$ pontuação da silhueta = \ frac {\ left (pq \ right)} {max \ left (p, q \ right)} $$
Aqui, é a distância média para os pontos no cluster mais próximo do qual o ponto de dados não faz parte. E, é a distância intra-cluster média para todos os pontos em seu próprio cluster.
Para encontrar o número ideal de clusters, precisamos executar o algoritmo de clusterização novamente, importando o metrics módulo do sklearnpacote. No exemplo a seguir, executaremos o algoritmo de agrupamento K-means para encontrar o número ideal de clusters -
Importe os pacotes necessários conforme mostrado -
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
Com a ajuda do código a seguir, geraremos o conjunto de dados bidimensional, contendo quatro blobs, usando make_blob de sklearn.dataset pacote.
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)
Inicialize as variáveis conforme mostrado -
scores = []
values = np.arange(2, 10)
Precisamos iterar o modelo K-means por meio de todos os valores e também treiná-lo com os dados de entrada.
for num_clusters in values:
kmeans = KMeans(init = 'k-means++', n_clusters = num_clusters, n_init = 10)
kmeans.fit(X)
Agora, estime a pontuação da silhueta para o modelo de agrupamento atual usando a métrica de distância euclidiana -
score = metrics.silhouette_score(X, kmeans.labels_,
metric = 'euclidean', sample_size = len(X))
A linha de código a seguir ajudará a exibir o número de clusters, bem como a pontuação do Silhouette.
print("\nNumber of clusters =", num_clusters)
print("Silhouette score =", score)
scores.append(score)
Você receberá a seguinte saída -
Number of clusters = 9
Silhouette score = 0.340391138371
num_clusters = np.argmax(scores) + values[0]
print('\nOptimal number of clusters =', num_clusters)
Agora, a saída para o número ideal de clusters seria a seguinte -
Optimal number of clusters = 2
Encontrar Vizinhos Mais Próximos
Se quisermos construir sistemas de recomendação, como um sistema de recomendação de filmes, precisamos entender o conceito de encontrar os vizinhos mais próximos. É porque o sistema de recomendação utiliza o conceito de vizinhos mais próximos.
o concept of finding nearest neighborspode ser definido como o processo de encontrar o ponto mais próximo ao ponto de entrada do conjunto de dados fornecido. O principal uso desse algoritmo KNN (K-mais próximos vizinhos) é construir sistemas de classificação que classificam um ponto de dados na proximidade do ponto de dados de entrada para várias classes.
O código Python fornecido abaixo ajuda a encontrar os vizinhos K-mais próximos de um determinado conjunto de dados -
Importe os pacotes necessários conforme mostrado abaixo. Aqui, estamos usando oNearestNeighbors módulo do sklearn pacote
import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors
Vamos agora definir os dados 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],])
Agora, precisamos definir os vizinhos mais próximos -
k = 3
Também precisamos fornecer os dados de teste a partir dos quais os vizinhos mais próximos podem ser encontrados -
test_data = [3.3, 2.9]
O código a seguir pode visualizar e plotar os dados de entrada definidos por nós -
plt.figure()
plt.title('Input data')
plt.scatter(A[:,0], A[:,1], marker = 'o', s = 100, color = 'black')
Agora, precisamos construir o vizinho mais próximo K. O objeto também precisa ser treinado
knn_model = NearestNeighbors(n_neighbors = k, algorithm = 'auto').fit(X)
distances, indices = knn_model.kneighbors([test_data])
Agora, podemos imprimir os K vizinhos mais próximos da seguinte forma
print("\nK Nearest Neighbors:")
for rank, index in enumerate(indices[0][:k], start = 1):
print(str(rank) + " is", A[index])
Podemos visualizar os vizinhos mais próximos junto com o ponto de dados de teste
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()
Resultado
K Nearest Neighbors
1 is [ 3.1 2.3]
2 is [ 3.9 3.5]
3 is [ 4.4 2.9]
Classificador de vizinhos mais próximos K
Um classificador de vizinhos mais próximos K (KNN) é um modelo de classificação que usa o algoritmo de vizinhos mais próximos para classificar um determinado ponto de dados. Implementamos o algoritmo KNN na última seção, agora vamos construir um classificador KNN usando esse algoritmo.
Conceito de classificador KNN
O conceito básico da classificação K-vizinho mais próximo é encontrar um número predefinido, ou seja, o 'k' - de amostras de treinamento mais próximas em distância de uma nova amostra, que deve ser classificada. Novas amostras receberão sua etiqueta dos próprios vizinhos. Os classificadores KNN têm uma constante definida pelo usuário fixa para o número de vizinhos que devem ser determinados. Para a distância, a distância euclidiana padrão é a escolha mais comum. O Classificador KNN trabalha diretamente nas amostras aprendidas, em vez de criar as regras de aprendizagem. O algoritmo KNN está entre os mais simples de todos os algoritmos de aprendizado de máquina. Ele tem tido bastante sucesso em um grande número de problemas de classificação e regressão, por exemplo, reconhecimento de caracteres ou análise de imagens.
Example
Estamos construindo um classificador KNN para reconhecer dígitos. Para isso, usaremos o conjunto de dados MNIST. Vamos escrever este código no Notebook Jupyter.
Importe os pacotes necessários conforme mostrado abaixo.
Aqui estamos usando o KNeighborsClassifier módulo do sklearn.neighbors pacote -
from sklearn.datasets import *
import pandas as pd
%matplotlib inline
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
import numpy as np
O código a seguir exibirá a imagem do dígito para verificar qual imagem temos que testar -
def Image_display(i):
plt.imshow(digit['images'][i],cmap = 'Greys_r')
plt.show()
Agora, precisamos carregar o conjunto de dados MNIST. Na verdade, há um total de 1797 imagens, mas estamos usando as primeiras 1600 imagens como amostra de treinamento e as 197 restantes seriam mantidas para fins de teste.
digit = load_digits()
digit_d = pd.DataFrame(digit['data'][0:1600])
Agora, ao exibir as imagens, podemos ver o resultado da seguinte forma -
Image_display(0)
Image_display (0)
A imagem de 0 é exibida da seguinte forma -
Image_display (9)
A imagem de 9 é exibida da seguinte forma -
digit.keys ()
Agora, precisamos criar o conjunto de dados de treinamento e teste e fornecer o conjunto de dados de teste aos classificadores KNN.
train_x = digit['data'][:1600]
train_y = digit['target'][:1600]
KNN = KNeighborsClassifier(20)
KNN.fit(train_x,train_y)
A saída a seguir criará o construtor do classificador K vizinho mais próximo -
KNeighborsClassifier(algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
metric_params = None, n_jobs = 1, n_neighbors = 20, p = 2,
weights = 'uniform')
Precisamos criar a amostra de teste fornecendo qualquer número arbitrário maior que 1600, que eram as amostras de treinamento.
test = np.array(digit['data'][1725])
test1 = test.reshape(1,-1)
Image_display(1725)
Image_display (6)
A imagem de 6 é exibida da seguinte forma -
Agora vamos prever os dados de teste da seguinte forma -
KNN.predict(test1)
O código acima irá gerar a seguinte saída -
array([6])
Agora, considere o seguinte -
digit['target_names']
O código acima irá gerar a seguinte saída -
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
Processamento de linguagem natural (PNL) refere-se ao método de IA de comunicação com sistemas inteligentes usando uma linguagem natural, como o inglês.
O processamento de linguagem natural é necessário quando você deseja que um sistema inteligente como o robô execute de acordo com suas instruções, quando você deseja ouvir a decisão de um sistema especialista clínico baseado em diálogo, etc.
O campo da PNL envolve fazer com que os computadores executem tarefas úteis com as linguagens naturais que os humanos usam. A entrada e saída de um sistema PNL pode ser -
- Speech
- Texto Escrito
Componentes da PNL
Nesta seção, aprenderemos sobre os diferentes componentes da PNL. Existem dois componentes da PNL. Os componentes são descritos abaixo -
Compreensão da linguagem natural (NLU)
Envolve as seguintes tarefas -
Mapear a entrada fornecida em linguagem natural em representações úteis.
Analisando diferentes aspectos da linguagem.
Geração de linguagem natural (NLG)
É o processo de produção de frases e sentenças significativas na forma de linguagem natural a partir de alguma representação interna. Envolve -
Text planning - Isso inclui recuperar o conteúdo relevante da base de conhecimento.
Sentence planning - Isso inclui escolher as palavras necessárias, formar frases significativas e definir o tom da frase.
Text Realization - Este é o mapeamento do plano da frase na estrutura da frase.
Dificuldades em NLU
O NLU é muito rico em forma e estrutura; no entanto, é ambíguo. Pode haver diferentes níveis de ambigüidade -
Ambigüidade lexical
Está em um nível muito primitivo, como o nível das palavras. Por exemplo, tratar a palavra “tabuleiro” como substantivo ou verbo?
Ambiguidade de nível de sintaxe
Uma frase pode ser analisada de diferentes maneiras. Por exemplo, “Ele levantou o besouro com a tampa vermelha”. - Ele usou boné para levantar o besouro ou levantou um besouro que tinha boné vermelho?
Ambigüidade referencial
Referindo-se a algo usando pronomes. Por exemplo, Rima foi para Gauri. Ela disse: “Estou cansada”. - Exatamente quem está cansado?
Terminologia de PNL
Vejamos agora alguns termos importantes na terminologia da PNL.
Phonology - É um estudo de organização de som sistematicamente.
Morphology - É um estudo de construção de palavras a partir de unidades de sentido primitivas.
Morpheme - É uma unidade primitiva de significado em uma linguagem.
Syntax- Refere-se a organizar palavras para formar uma frase. Também envolve determinar o papel estrutural das palavras na frase e nas frases.
Semantics - Preocupa-se com o significado das palavras e como combiná-las em frases e sentenças significativas.
Pragmatics - Lida com o uso e compreensão de frases em diferentes situações e como a interpretação da frase é afetada.
Discourse - Trata de como a frase imediatamente anterior pode afetar a interpretação da próxima frase.
World Knowledge - Inclui o conhecimento geral sobre o mundo.
Etapas em PNL
Esta seção mostra as diferentes etapas da PNL.
Análise Lexical
Envolve identificar e analisar a estrutura das palavras. Léxico de um idioma significa a coleção de palavras e frases em um idioma. A análise lexical está dividindo todo o pedaço de txt em parágrafos, sentenças e palavras.
Análise sintática (análise)
Envolve a análise gramatical das palavras da frase e a organização das palavras de uma maneira que mostra a relação entre as palavras. A frase como “A escola vai para o menino” é rejeitada pelo analisador sintático inglês.
Análise Semântica
Ele extrai o significado exato ou o significado do dicionário do texto. O texto é verificado quanto ao significado. Isso é feito mapeando estruturas sintáticas e objetos no domínio da tarefa. O analisador semântico desconsidera frases como “sorvete quente”.
Integração de Discurso
O significado de qualquer frase depende do significado da frase imediatamente anterior. Além disso, também traz o significado de frase imediatamente posterior.
Análise Pragmática
Durante isso, o que foi dito é reinterpretado sobre o que realmente significava. Envolve derivar aqueles aspectos da linguagem que requerem conhecimento do mundo real.
Neste capítulo, aprenderemos como começar a usar o Pacote do Natural Language Toolkit.
Pré-requisito
Se quisermos construir aplicativos com processamento de Linguagem Natural, a mudança de contexto torna isso mais difícil. O fator de contexto influencia como a máquina entende uma frase particular. Portanto, precisamos desenvolver aplicativos de linguagem natural usando abordagens de aprendizado de máquina para que a máquina também possa entender a maneira como um ser humano pode entender o contexto.
Para construir tais aplicações, usaremos o pacote Python chamado NLTK (Natural Language Toolkit Package).
Importando NLTK
Precisamos instalar o NLTK antes de usá-lo. Ele pode ser instalado com a ajuda do seguinte comando -
pip install nltk
Para construir um pacote conda para NLTK, use o seguinte comando -
conda install -c anaconda nltk
Agora, depois de instalar o pacote NLTK, precisamos importá-lo por meio do prompt de comando do python. Podemos importá-lo escrevendo o seguinte comando no prompt de comando do Python -
>>> import nltk
Baixando dados do NLTK
Agora, após importar o NLTK, precisamos baixar os dados necessários. Isso pode ser feito com a ajuda do seguinte comando no prompt de comando do Python -
>>> nltk.download()
Instalando outros pacotes necessários
Para construir aplicativos de processamento de linguagem natural usando NLTK, precisamos instalar os pacotes necessários. Os pacotes são os seguintes -
gensim
É uma biblioteca de modelagem semântica robusta, útil para muitos aplicativos. Podemos instalá-lo executando o seguinte comando -
pip install gensim
padronizar
É usado para fazer gensimpacote funcionar corretamente. Podemos instalá-lo executando o seguinte comando
pip install pattern
Conceito de tokenização, stemming e lematização
Nesta seção, entenderemos o que é tokenização, lematização e lematização.
Tokenização
Pode ser definido como o processo de quebrar o texto fornecido, ou seja, a sequência de caracteres em unidades menores chamadas tokens. Os tokens podem ser palavras, números ou sinais de pontuação. Também é chamado de segmentação de palavras. A seguir está um exemplo simples de tokenização -
Input - Manga, banana, abacaxi e maçã são todos frutas.
Output -
O processo de quebrar o texto fornecido pode ser feito com a ajuda de localizar os limites das palavras. O final de uma palavra e o início de uma nova palavra são chamados de limites de palavras. O sistema de escrita e a estrutura tipográfica das palavras influenciam os limites.
No módulo Python NLTK, temos diferentes pacotes relacionados à tokenização que podemos usar para dividir o texto em tokens de acordo com nossos requisitos. Alguns dos pacotes são os seguintes -
pacote sent_tokenize
Como o nome sugere, este pacote dividirá o texto de entrada em frases. Podemos importar este pacote com a ajuda do seguinte código Python -
from nltk.tokenize import sent_tokenize
pacote word_tokenize
Este pacote divide o texto de entrada em palavras. Podemos importar este pacote com a ajuda do seguinte código Python -
from nltk.tokenize import word_tokenize
Pacote WordPunctTokenizer
Este pacote divide o texto de entrada em palavras, bem como os sinais de pontuação. Podemos importar este pacote com a ajuda do seguinte código Python -
from nltk.tokenize import WordPuncttokenizer
Stemming
Ao trabalhar com palavras, encontramos muitas variações por motivos gramaticais. O conceito de variações aqui significa que temos que lidar com diferentes formas das mesmas palavras, comodemocracy, democratic, e democratization. É muito necessário que as máquinas entendam que essas diferentes palavras têm a mesma forma básica. Dessa forma, seria útil extrair as formas básicas das palavras enquanto analisamos o texto.
Podemos conseguir isso parando. Desse modo, podemos dizer que radicalização é o processo heurístico de extrair as formas básicas das palavras cortando as pontas das palavras.
No módulo Python NLTK, temos diferentes pacotes relacionados a lematização. Esses pacotes podem ser usados para obter as formas básicas da palavra. Esses pacotes usam algoritmos. Alguns dos pacotes são os seguintes -
Pacote PorterStemmer
Este pacote Python usa o algoritmo de Porter para extrair o formulário básico. Podemos importar este pacote com a ajuda do seguinte código Python -
from nltk.stem.porter import PorterStemmer
Por exemplo, se dermos a palavra ‘writing’ como entrada para este lematizador, obteremos a palavra ‘write’ após a retirada.
Pacote LancasterStemmer
Este pacote Python usará o algoritmo de Lancaster para extrair o formulário básico. Podemos importar este pacote com a ajuda do seguinte código Python -
from nltk.stem.lancaster import LancasterStemmer
Por exemplo, se dermos a palavra ‘writing’ como entrada para este lematizador, obteremos a palavra ‘write’ após a retirada.
Pacote SnowballStemmer
Este pacote Python usará o algoritmo da bola de neve para extrair o formulário básico. Podemos importar este pacote com a ajuda do seguinte código Python -
from nltk.stem.snowball import SnowballStemmer
Por exemplo, se dermos a palavra ‘writing’ como entrada para este lematizador, obteremos a palavra ‘write’ após a retirada.
Todos esses algoritmos têm diferentes níveis de rigidez. Se compararmos esses três lematizadores, então os lematizadores Porter são os menos estritos e Lancaster é o mais estrito. A haste de bola de neve é boa para usar em termos de velocidade e rigidez.
Lemmatização
Também podemos extrair a forma básica das palavras por lematização. Ele basicamente faz essa tarefa com o uso de um vocabulário e análise morfológica das palavras, normalmente com o objetivo de remover apenas as desinências flexionais. Esse tipo de forma básica de qualquer palavra é chamado lema.
A principal diferença entre lematização e lematização é o uso de vocabulário e análise morfológica das palavras. Outra diferença é que o radical mais comumente reduz as palavras derivacionalmente relacionadas, ao passo que a lematização comumente apenas reduz as diferentes formas flexionais de um lema. Por exemplo, se fornecermos a palavra saw como a palavra de entrada, o radical pode retornar a palavra 's', mas a lematização tentará retornar a palavra see ou saw dependendo se o uso do token for um verbo ou um substantivo.
No módulo Python NLTK, temos o seguinte pacote relacionado ao processo de lematização que podemos usar para obter as formas básicas de palavras -
Pacote WordNetLemmatizer
Este pacote Python extrairá a forma básica da palavra dependendo se ela é usada como substantivo ou verbo. Podemos importar este pacote com a ajuda do seguinte código Python -
from nltk.stem import WordNetLemmatizer
Chunking: Dividindo Dados em Chunks
É um dos processos importantes no processamento de linguagem natural. A principal tarefa do agrupamento é identificar as classes gramaticais e frases curtas, como substantivos. Já estudamos o processo de tokenização, a criação de tokens. O chunking é basicamente a rotulação desses tokens. Em outras palavras, o chunking nos mostrará a estrutura da frase.
Na seção seguinte, aprenderemos sobre os diferentes tipos de Chunking.
Tipos de chunking
Existem dois tipos de agrupamento. Os tipos são os seguintes -
Chunking up
Nesse processo de fragmentação, o objeto, as coisas etc. passam a ser mais gerais e a linguagem fica mais abstrata. Existem mais chances de acordo. Nesse processo, diminuímos o zoom. Por exemplo, se dividirmos a questão “para que propósito os carros são”? Podemos obter a resposta “transporte”.
Chunking down
Nesse processo de fragmentação, o objeto, as coisas etc. passam a ser mais específicos e a linguagem fica mais penetrada. A estrutura mais profunda seria examinada na fragmentação. Nesse processo, aumentamos o zoom. Por exemplo, se analisarmos a questão “Fale especificamente sobre um carro”? Obteremos informações menores sobre o carro.
Example
Neste exemplo, faremos chunking de frases substantivas, uma categoria de chunking que encontrará os pedaços de sintagmas nominais na frase, usando o módulo NLTK em Python -
Follow these steps in python for implementing noun phrase chunking −
Step 1- Nesta etapa, precisamos definir a gramática para chunking. Consistiria nas regras que devemos seguir.
Step 2- Nesta etapa, precisamos criar um analisador de bloco. Ele analisaria a gramática e forneceria a saída.
Step 3 - Nesta última etapa, a saída é produzida em formato de árvore.
Vamos importar o pacote NLTK necessário da seguinte maneira -
import nltk
Agora, precisamos definir a frase. Aqui, DT significa o determinante, VBP significa o verbo, JJ significa o adjetivo, IN significa a preposição e NN significa o substantivo.
sentence=[("a","DT"),("clever","JJ"),("fox","NN"),("was","VBP"),
("jumping","VBP"),("over","IN"),("the","DT"),("wall","NN")]
Agora, precisamos dar a gramática. Aqui, daremos a gramática na forma de expressão regular.
grammar = "NP:{<DT>?<JJ>*<NN>}"
Precisamos definir um analisador que irá analisar a gramática.
parser_chunking = nltk.RegexpParser(grammar)
O analisador analisa a frase da seguinte maneira -
parser_chunking.parse(sentence)
Em seguida, precisamos obter a saída. A saída é gerada na variável simples chamadaoutput_chunk.
Output_chunk = parser_chunking.parse(sentence)
Após a execução do código a seguir, podemos desenhar nossa saída na forma de uma árvore.
output.draw()
Modelo do saco de palavras (BoW)
Bag of Word (BoW), um modelo em processamento de linguagem natural, é basicamente utilizado para extrair os recursos do texto para que o texto possa ser usado na modelagem tanto quanto em algoritmos de aprendizado de máquina.
Agora surge a questão de por que precisamos extrair os recursos do texto. É porque os algoritmos de aprendizado de máquina não podem trabalhar com dados brutos e precisam de dados numéricos para que possam extrair informações significativas deles. A conversão de dados de texto em dados numéricos é chamada de extração de recurso ou codificação de recurso.
Como funciona
Esta é uma abordagem muito simples para extrair os recursos do texto. Suponha que temos um documento de texto e queremos convertê-lo em dados numéricos ou, digamos, queremos extrair os recursos dele, então, primeiro de tudo, este modelo extrai um vocabulário de todas as palavras no documento. Então, usando uma matriz de termos de documento, ele construirá um modelo. Dessa forma, BoW representa o documento apenas como um pacote de palavras. Qualquer informação sobre a ordem ou estrutura das palavras no documento é descartada.
Conceito de matriz de termos de documento
O algoritmo BoW constrói um modelo usando a matriz de termos do documento. Como o nome sugere, a matriz de termos do documento é a matriz de várias contagens de palavras que ocorrem no documento. Com a ajuda desta matriz, o documento de texto pode ser representado como uma combinação ponderada de várias palavras. Ao definir o limite e escolher as palavras que são mais significativas, podemos construir um histograma de todas as palavras nos documentos que podem ser usadas como um vetor de recurso. A seguir está um exemplo para entender o conceito de matriz de termos de documento -
Example
Suponha que temos as seguintes duas sentenças -
Sentence 1 - Estamos usando o modelo do Saco de Palavras.
Sentence 2 - O modelo Bag of Words é usado para extrair os recursos.
Agora, considerando essas duas frases, temos as seguintes 13 palavras distintas -
- we
- are
- using
- the
- bag
- of
- words
- model
- is
- used
- for
- extracting
- features
Agora, precisamos construir um histograma para cada frase usando a contagem de palavras em cada frase -
Sentence 1 - [1,1,1,1,1,1,1,1,1,0,0,0,0,0]
Sentence 2 - [0,0,0,1,1,1,1,1,1,1,1,1,1,1]
Desta forma, temos os vetores de características que foram extraídos. Cada vetor de recurso tem 13 dimensões porque temos 13 palavras distintas.
Conceito de Estatística
O conceito das estatísticas é denominado TermFrequency-Inverse Document Frequency (tf-idf). Cada palavra é importante no documento. As estatísticas nos ajudam a entender a importância de cada palavra.
Frequência do termo (tf)
É a medida da frequência com que cada palavra aparece em um documento. Ele pode ser obtido dividindo a contagem de cada palavra pelo número total de palavras em um determinado documento.
Frequência inversa do documento (idf)
É a medida de quão única uma palavra é para este documento em um determinado conjunto de documentos. Para calcular idf e formular um vetor de características distintas, precisamos reduzir o peso de palavras que ocorrem comumente, como o e pesar as palavras raras.
Construindo um modelo de saco de palavras em NLTK
Nesta seção, definiremos uma coleção de strings usando CountVectorizer para criar vetores a partir dessas sentenças.
Deixe-nos importar o pacote necessário -
from sklearn.feature_extraction.text import CountVectorizer
Agora defina o conjunto de frases.
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_)
O programa acima gera a saída conforme mostrado abaixo. Isso mostra que temos 13 palavras distintas nas duas frases acima -
{'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}
Esses são os vetores de recursos (texto para formato numérico) que podem ser usados para aprendizado de máquina.
Resolvendo problemas
Nesta seção, resolveremos alguns problemas relacionados.
Predição de categoria
Em um conjunto de documentos, não apenas as palavras, mas a categoria das palavras também é importante; em qual categoria de texto uma determinada palavra se enquadra. Por exemplo, queremos prever se uma determinada frase pertence à categoria e-mail, notícias, esportes, computador, etc. No exemplo a seguir, vamos usar tf-idf para formular um vetor de recurso para encontrar a categoria de documentos. Usaremos os dados de 20 conjuntos de dados de newsgroups da sklearn.
Precisamos importar os pacotes necessários -
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
Defina o mapa da categoria. Estamos usando cinco categorias diferentes: Religião, Automóveis, Esportes, Eletrônica e Espaço.
category_map = {'talk.religion.misc':'Religion','rec.autos''Autos',
'rec.sport.hockey':'Hockey','sci.electronics':'Electronics', 'sci.space': 'Space'}
Crie o conjunto de treinamento -
training_data = fetch_20newsgroups(subset = 'train',
categories = category_map.keys(), shuffle = True, random_state = 5)
Construa um vetorizador de contagem e extraia as contagens de termos -
vectorizer_count = CountVectorizer()
train_tc = vectorizer_count.fit_transform(training_data.data)
print("\nDimensions of training data:", train_tc.shape)
O transformador tf-idf é criado da seguinte maneira -
tfidf = TfidfTransformer()
train_tfidf = tfidf.fit_transform(train_tc)
Agora, defina os dados de teste -
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'
]
Os dados acima nos ajudarão a treinar um classificador Multinomial Naive Bayes -
classifier = MultinomialNB().fit(train_tfidf, training_data.target)
Transforme os dados de entrada usando o vetorizador de contagem -
input_tc = vectorizer_count.transform(input_data)
Agora, vamos transformar os dados vetorizados usando o transformador tfidf -
input_tfidf = tfidf.transform(input_tc)
Vamos prever as categorias de saída -
predictions = classifier.predict(input_tfidf)
A saída é gerada da seguinte forma -
for sent, category in zip(input_data, predictions):
print('\nInput Data:', sent, '\n Category:', \
category_map[training_data.target_names[category]])
O preditor de categoria gera a seguinte saída -
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
Localizador de gênero
Nessa definição do problema, um classificador seria treinado para encontrar o gênero (masculino ou feminino) fornecendo os nomes. Precisamos usar uma heurística para construir um vetor de recursos e treinar o classificador. Estaremos usando os dados rotulados do pacote scikit-learn. A seguir está o código Python para construir um localizador de gênero -
Deixe-nos importar os pacotes necessários -
import random
from nltk import NaiveBayesClassifier
from nltk.classify import accuracy as nltk_accuracy
from nltk.corpus import names
Agora precisamos extrair as últimas N letras da palavra de entrada. Essas letras funcionarão como recursos -
def extract_features(word, N = 2):
last_n_letters = word[-N:]
return {'feature': last_n_letters.lower()}
if __name__=='__main__':
Crie os dados de treinamento usando nomes rotulados (masculinos e femininos) disponíveis em 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)
Agora, os dados de teste serão criados da seguinte maneira -
namesInput = ['Rajesh', 'Gaurav', 'Swati', 'Shubha']
Defina o número de amostras usadas para treinar e testar com o seguinte código
train_sample = int(0.8 * len(data))
Agora, precisamos iterar em diferentes comprimentos para que a precisão possa ser comparada -
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)
A precisão do classificador pode ser calculada da seguinte forma -
accuracy_classifier = round(100 * nltk_accuracy(classifier, test_data), 2)
print('Accuracy = ' + str(accuracy_classifier) + '%')
Agora, podemos prever a saída -
for name in namesInput:
print(name, '==>', classifier.classify(extract_features(name, i)))
O programa acima irá gerar a seguinte saída -
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
Na saída acima, podemos ver que a precisão no número máximo de letras finais são dois e está diminuindo conforme o número de letras finais aumenta.
Modelagem de Tópico: Identificando Padrões em Dados de Texto
Sabemos que geralmente os documentos são agrupados em tópicos. Às vezes, precisamos identificar os padrões em um texto que correspondem a um tópico específico. A técnica para fazer isso é chamada de modelagem de tópicos. Em outras palavras, podemos dizer que a modelagem de tópicos é uma técnica para descobrir temas abstratos ou estruturas ocultas em um determinado conjunto de documentos.
Podemos usar a técnica de modelagem de tópicos nos seguintes cenários -
Classificação de Texto
Com a ajuda da modelagem de tópicos, a classificação pode ser melhorada porque agrupa palavras semelhantes em vez de usar cada palavra separadamente como um recurso.
Sistemas de Recomendação
Com a ajuda da modelagem de tópicos, podemos construir os sistemas de recomendação usando medidas de similaridade.
Algoritmos para modelagem de tópicos
A modelagem de tópicos pode ser implementada usando algoritmos. Os algoritmos são os seguintes -
Alocação Latent Dirichlet (LDA)
Este algoritmo é o mais popular para modelagem de tópicos. Ele usa os modelos gráficos probabilísticos para implementar a modelagem de tópicos. Precisamos importar o pacote gensim em Python para usar o slgorithm LDA.
Análise Semântica Latente (LDA) ou Indexação Semântica Latente (LSI)
Este algoritmo é baseado na Álgebra Linear. Basicamente, ele usa o conceito de SVD (Singular Value Decomposition) na matriz de termos do documento.
Fatoração de matriz não negativa (NMF)
Também é baseado na Álgebra Linear.
Todos os algoritmos mencionados acima para modelagem de tópicos teriam o number of topics como um parâmetro, Document-Word Matrix como uma entrada e WTM (Word Topic Matrix) E TDM (Topic Document Matrix) como saída.
Prever o próximo em uma determinada sequência de entrada é outro conceito importante no aprendizado de máquina. Este capítulo fornece uma explicação detalhada sobre a análise de dados de série temporal.
Introdução
Dados de série temporal significam os dados que estão em uma série de intervalos de tempo específicos. Se quisermos construir predição de sequência no aprendizado de máquina, temos que lidar com tempo e dados sequenciais. Os dados da série são um resumo dos dados sequenciais. A ordenação de dados é um recurso importante dos dados sequenciais.
Conceito Básico de Análise de Sequência ou Análise de Séries Temporais
A análise de sequência ou análise de série temporal serve para prever o próximo em uma determinada sequência de entrada com base no observado anteriormente. A previsão pode ser de qualquer coisa que venha a seguir: um símbolo, um número, clima no dia seguinte, próximo termo na fala etc. A análise de sequência pode ser muito útil em aplicações como análise de mercado de ações, previsão do tempo e recomendações de produtos.
Example
Considere o exemplo a seguir para entender a previsão de sequência. AquiA,B,C,D são os valores dados e você deve prever o valor E usando um modelo de previsão de sequência.
Instalando Pacotes Úteis
Para análise de dados de série temporal usando Python, precisamos instalar os seguintes pacotes -
Pandas
Pandas é uma biblioteca de código aberto licenciada por BSD que fornece alto desempenho, facilidade de uso de estrutura de dados e ferramentas de análise de dados para Python. Você pode instalar o Pandas com a ajuda do seguinte comando -
pip install pandas
Se você está usando o Anaconda e deseja instalar usando o conda gerenciador de pacotes, então você pode usar o seguinte comando -
conda install -c anaconda pandas
hmmlearn
É uma biblioteca de código aberto licenciada por BSD que consiste em algoritmos e modelos simples para aprender Modelos Ocultos de Markov (HMM) em Python. Você pode instalá-lo com a ajuda do seguinte comando -
pip install hmmlearn
Se você está usando o Anaconda e deseja instalar usando o conda gerenciador de pacotes, então você pode usar o seguinte comando -
conda install -c omnia hmmlearn
PyStruct
É uma biblioteca estruturada de aprendizagem e previsão. Os algoritmos de aprendizagem implementados em PyStruct têm nomes como campos aleatórios condicionais (CRF), Redes Aleatórias de Markov de Margem Máxima (M3N) ou máquinas de vetores de suporte estrutural. Você pode instalá-lo com a ajuda do seguinte comando -
pip install pystruct
CVXOPT
É usado para otimização convexa com base na linguagem de programação Python. Também é um pacote de software livre. Você pode instalá-lo com a ajuda do seguinte comando -
pip install cvxopt
Se você está usando o Anaconda e deseja instalar usando o conda gerenciador de pacotes, então você pode usar o seguinte comando -
conda install -c anaconda cvdoxt
Pandas: Manipulação, divisão e extração de estatísticas de dados de série temporal
O Pandas é uma ferramenta muito útil se você tiver que trabalhar com dados de séries temporais. Com a ajuda do Pandas, você pode realizar o seguinte -
Crie um intervalo de datas usando o pd.date_range pacote
Indexar pandas com datas usando o pd.Series pacote
Realize uma nova amostragem usando o ts.resample pacote
Mudar a frequência
Exemplo
O exemplo a seguir mostra como manipular e dividir os dados da série temporal usando o Pandas. Observe que aqui estamos usando os dados de Oscilação Ártica Mensal, que podem ser baixados de Monthly.ao.index.b50.current.ascii e podem ser convertidos para o formato de texto para nosso uso.
Tratamento de dados de série temporal
Para lidar com dados de série temporal, você terá que realizar as seguintes etapas -
A primeira etapa envolve a importação dos seguintes pacotes -
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
Em seguida, defina uma função que irá ler os dados do arquivo de entrada, conforme mostrado no código fornecido abaixo -
def read_data(input_file):
input_data = np.loadtxt(input_file, delimiter = None)
Agora, converta esses dados em séries temporais. Para isso, crie o intervalo de datas de nossa série temporal. Neste exemplo, mantemos um mês como frequência de dados. Nosso arquivo contém os dados que começam em janeiro de 1950.
dates = pd.date_range('1950-01', periods = input_data.shape[0], freq = 'M')
Nesta etapa, criamos os dados da série temporal com a ajuda do Pandas Series, conforme mostrado abaixo -
output = pd.Series(input_data[:, index], index = dates)
return output
if __name__=='__main__':
Insira o caminho do arquivo de entrada conforme mostrado aqui -
input_file = "/Users/admin/AO.txt"
Agora, converta a coluna para o formato de série temporal, conforme mostrado aqui -
timeseries = read_data(input_file)
Finalmente, plote e visualize os dados, usando os comandos mostrados -
plt.figure()
timeseries.plot()
plt.show()
Você observará os gráficos conforme mostrado nas imagens a seguir -
Fatiar dados de série temporal
O fatiamento envolve a recuperação de apenas uma parte dos dados da série temporal. Como parte do exemplo, estamos dividindo os dados apenas de 1980 a 1990. Observe o seguinte código que executa esta tarefa -
timeseries['1980':'1990'].plot()
<matplotlib.axes._subplots.AxesSubplot at 0xa0e4b00>
plt.show()
Ao executar o código para dividir os dados da série temporal, você pode observar o gráfico a seguir, conforme mostrado na imagem aqui -
Extração de estatística de dados de série temporal
Você terá que extrair algumas estatísticas de um dado dado, nos casos em que você precisa tirar alguma conclusão importante. Média, variância, correlação, valor máximo e valor mínimo são algumas dessas estatísticas. Você pode usar o seguinte código se quiser extrair essas estatísticas de dados de uma determinada série temporal -
Significar
Você pode usar o mean() função, para encontrar a média, conforme mostrado aqui -
timeseries.mean()
Então, a saída que você observará para o exemplo discutido é -
-0.11143128165238671
Máximo
Você pode usar o max() função, para encontrar o máximo, conforme mostrado aqui -
timeseries.max()
Então, a saída que você observará para o exemplo discutido é -
3.4952999999999999
Mínimo
Você pode usar a função min (), para encontrar o mínimo, conforme mostrado aqui -
timeseries.min()
Então, a saída que você observará para o exemplo discutido é -
-4.2656999999999998
Obtendo tudo de uma vez
Se quiser calcular todas as estatísticas de uma vez, você pode usar o describe() função conforme mostrado aqui -
timeseries.describe()
Então, a saída que você observará para o exemplo discutido é -
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
Reamostragem
Você pode reamostrar os dados para uma frequência de tempo diferente. Os dois parâmetros para realizar a reamostragem são -
- Período de tempo
- Method
Reamostragem com média ()
Você pode usar o código a seguir para reamostrar os dados com o método mean (), que é o método padrão -
timeseries_mm = timeseries.resample("A").mean()
timeseries_mm.plot(style = 'g--')
plt.show()
Então, você pode observar o gráfico a seguir como a saída da reamostragem usando mean () -
Reamostragem com mediana ()
Você pode usar o seguinte código para reamostrar os dados usando o median()método -
timeseries_mm = timeseries.resample("A").median()
timeseries_mm.plot()
plt.show()
Então, você pode observar o gráfico a seguir como a saída da reamostragem com mediana () -
Média móvel
Você pode usar o seguinte código para calcular a média móvel (móvel) -
timeseries.rolling(window = 12, center = False).mean().plot(style = '-g')
plt.show()
Então, você pode observar o seguinte gráfico como a saída da média móvel (móvel) -
Analisando dados sequenciais por modelo de Markov Oculto (HMM)
HMM é um modelo estatístico amplamente utilizado para dados com continuação e extensibilidade, como análise de mercado de ações de séries temporais, exame de saúde e reconhecimento de fala. Esta seção trata em detalhes da análise de dados sequenciais usando o modelo Hidden Markov (HMM).
Modelo de Markov Oculto (HMM)
O HMM é um modelo estocástico que se baseia no conceito de cadeia de Markov com base na suposição de que a probabilidade de estatísticas futuras depende apenas do estado atual do processo, e não de qualquer estado que o precedeu. Por exemplo, ao jogar uma moeda, não podemos dizer que o resultado do quinto lance será uma cara. Isso porque uma moeda não tem memória e o próximo resultado não depende do resultado anterior.
Matematicamente, o HMM consiste nas seguintes variáveis -
Estados (S)
É um conjunto de estados ocultos ou latentes presentes em um HMM. É denotado por S.
Símbolos de saída (O)
É um conjunto de possíveis símbolos de saída presentes em um HMM. É denotado por O.
Matriz de probabilidade de transição de estado (A)
É a probabilidade de fazer a transição de um estado para cada um dos outros estados. É denotado por A.
Matriz de probabilidade de emissão de observação (B)
É a probabilidade de emitir / observar um símbolo em um determinado estado. É denotado por B.
Matriz de probabilidade anterior (Π)
É a probabilidade de iniciar em um determinado estado a partir de vários estados do sistema. É denotado por Π.
Portanto, um HMM pode ser definido como = (S,O,A,B,),
Onde,
- S = {s1,s2,…,sN} é um conjunto de N estados possíveis,
- O = {o1,o2,…,oM} é um conjunto de M possíveis símbolos de observação,
- A é um NN Matriz de Probabilidade de Transição (TPM),
- B é um NM observação ou Matriz de Probabilidade de Emissão (EPM),
- π é um vetor de distribuição de probabilidade de estado inicial N dimensional.
Exemplo: análise de dados do mercado de ações
Neste exemplo, vamos analisar os dados do mercado de ações, passo a passo, para ter uma ideia de como o HMM funciona com dados sequenciais ou séries temporais. Observe que estamos implementando este exemplo em Python.
Importe os pacotes necessários conforme mostrado abaixo -
import datetime
import warnings
Agora, use os dados do mercado de ações do matpotlib.finance pacote, conforme mostrado aqui -
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
Carregue os dados de uma data de início e de término, ou seja, entre duas datas específicas, conforme mostrado aqui -
start_date = datetime.date(1995, 10, 10)
end_date = datetime.date(2015, 4, 25)
quotes = quotes_historical_yahoo_och1('INTC', start_date, end_date)
Nesta etapa, extrairemos as cotações de fechamento todos os dias. Para isso, use o seguinte comando -
closing_quotes = np.array([quote[2] for quote in quotes])
Agora, vamos extrair o volume de ações negociadas a cada dia. Para isso, use o seguinte comando -
volumes = np.array([quote[5] for quote in quotes])[1:]
Aqui, pegue a diferença percentual dos preços de fechamento das ações, usando o código mostrado abaixo -
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])
Nesta etapa, crie e treine o HMM gaussiano. Para isso, use o seguinte código -
hmm = GaussianHMM(n_components = 7, covariance_type = 'diag', n_iter = 1000)
with warnings.catch_warnings():
warnings.simplefilter('ignore')
hmm.fit(training_data)
Agora, gere dados usando o modelo HMM, usando os comandos mostrados -
num_samples = 300
samples, _ = hmm.sample(num_samples)
Por fim, nesta etapa, traçamos e visualizamos a diferença percentual e o volume de ações negociadas como produto na forma de gráfico.
Use o seguinte código para traçar e visualizar as porcentagens de diferença -
plt.figure()
plt.title('Difference percentages')
plt.plot(np.arange(num_samples), samples[:, 0], c = 'black')
Use o seguinte código para traçar e visualizar o volume de ações negociadas -
plt.figure()
plt.title('Volume of shares')
plt.plot(np.arange(num_samples), samples[:, 1], c = 'black')
plt.ylim(ymin = 0)
plt.show()
Neste capítulo, aprenderemos sobre o reconhecimento de fala usando IA com Python.
A fala é o meio mais básico de comunicação humana adulta. O objetivo básico do processamento da fala é fornecer uma interação entre um ser humano e uma máquina.
O sistema de processamento de fala tem principalmente três tarefas -
First, reconhecimento de fala que permite que a máquina capture as palavras, frases e sentenças que falamos
Second, processamento de linguagem natural para permitir que a máquina entenda o que falamos, e
Third, síntese de voz para permitir que a máquina fale.
Este capítulo enfoca speech recognition, o processo de compreensão das palavras faladas por seres humanos. Lembre-se de que os sinais de fala são captados com a ajuda de um microfone e então devem ser compreendidos pelo sistema.
Construindo um Reconhecedor de Fala
O reconhecimento de fala ou reconhecimento automático de fala (ASR) é o centro das atenções para projetos de IA, como a robótica. Sem ASR, não é possível imaginar um robô cognitivo interagindo com um humano. No entanto, não é muito fácil construir um reconhecedor de fala.
Dificuldades em desenvolver um sistema de reconhecimento de fala
O desenvolvimento de um sistema de reconhecimento de voz de alta qualidade é realmente um problema difícil. A dificuldade da tecnologia de reconhecimento de voz pode ser amplamente caracterizada ao longo de uma série de dimensões, conforme discutido abaixo -
Size of the vocabulary- O tamanho do vocabulário afeta a facilidade de desenvolvimento de um ASR. Considere os seguintes tamanhos de vocabulário para uma melhor compreensão.
Um vocabulário pequeno consiste de 2 a 100 palavras, por exemplo, como em um sistema de menu de voz
Um vocabulário de tamanho médio consiste em várias centenas a 1.000 de palavras, por exemplo, como em uma tarefa de recuperação de banco de dados
Um vocabulário de tamanho grande consiste em vários 10.000 palavras, como em uma tarefa de ditado geral.
Channel characteristics- A qualidade do canal também é uma dimensão importante. Por exemplo, a fala humana contém alta largura de banda com faixa de frequência total, enquanto a fala por telefone consiste em baixa largura de banda com faixa de frequência limitada. Observe que é mais difícil no último.
Speaking mode- A facilidade de desenvolver um ASR também depende do modo de fala, ou seja, se a fala está em modo de palavra isolada, ou modo de palavra conectada, ou em modo de fala contínua. Observe que uma fala contínua é mais difícil de reconhecer.
Speaking style- Um discurso lido pode ser em um estilo formal, ou espontâneo e coloquial com estilo casual. Este último é mais difícil de reconhecer.
Speaker dependency- A fala pode ser dependente do locutor, adaptável do locutor ou independente do locutor. Um alto-falante independente é o mais difícil de construir.
Type of noise- O ruído é outro fator a considerar ao desenvolver um ASR. A relação sinal / ruído pode estar em vários intervalos, dependendo do ambiente acústico que observa menos ou mais ruído de fundo -
Se a relação sinal-ruído for maior que 30dB, é considerada uma faixa alta
Se a relação sinal-ruído estiver entre 30dB e 10db, é considerado como SNR médio
Se a relação sinal-ruído for inferior a 10dB, é considerada uma faixa baixa
Microphone characteristics- A qualidade do microfone pode ser boa, média ou abaixo da média. Além disso, a distância entre a boca e o microfone pode variar. Esses fatores também devem ser considerados para sistemas de reconhecimento.
Observe que, quanto maior o tamanho do vocabulário, mais difícil é realizar o reconhecimento.
Por exemplo, o tipo de ruído de fundo, como ruído estacionário, não humano, fala de fundo e diafonia por outros alto-falantes também contribui para a dificuldade do problema.
Apesar dessas dificuldades, os pesquisadores trabalharam muito em vários aspectos da fala, como entender o sinal da fala, o locutor e identificar os sotaques.
Você terá que seguir as etapas abaixo para construir um reconhecedor de fala -
Visualizando sinais de áudio - Lendo de um arquivo e trabalhando nele
Esta é a primeira etapa na construção de um sistema de reconhecimento de voz, pois dá uma compreensão de como um sinal de áudio é estruturado. Algumas etapas comuns que podem ser seguidas para trabalhar com sinais de áudio são as seguintes -
Gravação
Quando você tiver que ler o sinal de áudio de um arquivo, grave-o usando um microfone, primeiro.
Amostragem
Ao gravar com microfone, os sinais são armazenados em formato digitalizado. Mas para trabalhar nisso, a máquina precisa deles na forma numérica discreta. Portanto, devemos realizar a amostragem em uma certa frequência e converter o sinal na forma numérica discreta. A escolha da alta frequência para amostragem implica que, quando os humanos ouvem o sinal, eles o sentem como um sinal de áudio contínuo.
Exemplo
O exemplo a seguir mostra uma abordagem gradativa para analisar um sinal de áudio, usando Python, que é armazenado em um arquivo. A frequência desse sinal de áudio é 44.100 Hz.
Importe os pacotes necessários conforme mostrado aqui -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
Agora, leia o arquivo de áudio armazenado. Ele retornará dois valores: a frequência de amostragem e o sinal de áudio. Forneça o caminho do arquivo de áudio onde ele está armazenado, conforme mostrado aqui -
frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")
Exiba os parâmetros como frequência de amostragem do sinal de áudio, tipo de dados do sinal e sua duração, usando os comandos mostrados -
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')
Esta etapa envolve a normalização do sinal conforme mostrado abaixo -
audio_signal = audio_signal / np.power(2, 15)
Nesta etapa, estamos extraindo os primeiros 100 valores desse sinal para visualização. Use os seguintes comandos para este propósito -
audio_signal = audio_signal [:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(frequency_sampling)
Agora, visualize o sinal usando os comandos abaixo -
plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time (milliseconds)')
plt.ylabel('Amplitude')
plt.title('Input audio signal')
plt.show()
Você seria capaz de ver um gráfico de saída e dados extraídos para o sinal de áudio acima, conforme mostrado na imagem aqui
Signal shape: (132300,)
Signal Datatype: int16
Signal duration: 3.0 seconds
Caracterizando o Sinal de Áudio: Transformando para Domínio de Freqüência
A caracterização de um sinal de áudio envolve a conversão do sinal do domínio do tempo em domínio da frequência e a compreensão de seus componentes de frequência por. Esta é uma etapa importante porque fornece muitas informações sobre o sinal. Você pode usar uma ferramenta matemática como a Transformação de Fourier para realizar essa transformação.
Exemplo
O exemplo a seguir mostra, passo a passo, como caracterizar o sinal, em Python, que fica armazenado em um arquivo. Observe que aqui estamos usando a ferramenta matemática da Transformada de Fourier para convertê-la no domínio da frequência.
Importe os pacotes necessários, conforme mostrado aqui -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
Agora, leia o arquivo de áudio armazenado. Ele retornará dois valores: a frequência de amostragem e o sinal de áudio. Forneça o caminho do arquivo de áudio onde ele está armazenado, conforme mostrado no comando aqui -
frequency_sampling, audio_signal = wavfile.read("/Users/admin/sample.wav")
Nesta etapa, exibiremos os parâmetros como frequência de amostragem do sinal de áudio, tipo de dados do sinal e sua duração, usando os comandos fornecidos abaixo -
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')
Nesta etapa, precisamos normalizar o sinal, conforme mostrado no seguinte comando -
audio_signal = audio_signal / np.power(2, 15)
Esta etapa envolve extrair o comprimento e metade do comprimento do sinal. Use os seguintes comandos para este propósito -
length_signal = len(audio_signal)
half_length = np.ceil((length_signal + 1) / 2.0).astype(np.int)
Agora, precisamos aplicar ferramentas matemáticas para a transformação no domínio da frequência. Aqui estamos usando a transformada de Fourier.
signal_frequency = np.fft.fft(audio_signal)
Agora, faça a normalização do sinal no domínio da frequência e eleve-o ao quadrado
signal_frequency = abs(signal_frequency[0:half_length]) / length_signal
signal_frequency **= 2
Em seguida, extraia o comprimento e metade do comprimento do sinal transformado de frequência -
len_fts = len(signal_frequency)
Observe que o sinal transformado de Fourier deve ser ajustado para casos pares e ímpares.
if length_signal % 2:
signal_frequency[1:len_fts] *= 2
else:
signal_frequency[1:len_fts-1] *= 2
Agora, extraia a potência em decibal (dB) -
signal_power = 10 * np.log10(signal_frequency)
Ajuste a frequência em kHz para o eixo X -
x_axis = np.arange(0, len_half, 1) * (frequency_sampling / length_signal) / 1000.0
Agora, visualize a caracterização do sinal da seguinte forma -
plt.figure()
plt.plot(x_axis, signal_power, color='black')
plt.xlabel('Frequency (kHz)')
plt.ylabel('Signal power (dB)')
plt.show()
Você pode observar o gráfico de saída do código acima, conforme mostrado na imagem abaixo -
Gerando Sinal de Áudio Monótono
As duas etapas que você viu até agora são importantes para aprender sobre os sinais. Agora, esta etapa será útil se você deseja gerar o sinal de áudio com alguns parâmetros predefinidos. Observe que esta etapa salvará o sinal de áudio em um arquivo de saída.
Exemplo
No exemplo a seguir, vamos gerar um sinal monótono, usando Python, que será armazenado em um arquivo. Para isso, você terá que seguir os seguintes passos -
Importe os pacotes necessários conforme mostrado -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io.wavfile import write
Forneça o arquivo onde o arquivo de saída deve ser salvo
output_file = 'audio_signal_generated.wav'
Agora, especifique os parâmetros de sua escolha, como mostrado -
duration = 4 # in seconds
frequency_sampling = 44100 # in Hz
frequency_tone = 784
min_val = -4 * np.pi
max_val = 4 * np.pi
Nesta etapa, podemos gerar o sinal de áudio, conforme mostrado -
t = np.linspace(min_val, max_val, duration * frequency_sampling)
audio_signal = np.sin(2 * np.pi * tone_freq * t)
Agora, salve o arquivo de áudio no arquivo de saída -
write(output_file, frequency_sampling, signal_scaled)
Extraia os primeiros 100 valores para o nosso gráfico, conforme mostrado -
audio_signal = audio_signal[:100]
time_axis = 1000 * np.arange(0, len(signal), 1) / float(sampling_freq)
Agora, visualize o sinal de áudio gerado da seguinte forma -
plt.plot(time_axis, signal, color='blue')
plt.xlabel('Time in milliseconds')
plt.ylabel('Amplitude')
plt.title('Generated audio signal')
plt.show()
Você pode observar o gráfico conforme mostrado na figura dada aqui -
Extração de recurso da fala
Esta é a etapa mais importante na construção de um reconhecedor de fala porque, depois de converter o sinal de fala no domínio da frequência, devemos convertê-lo na forma utilizável de vetor de características. Podemos usar diferentes técnicas de extração de recursos como MFCC, PLP, PLP-RASTA etc. para esse propósito.
Exemplo
No exemplo a seguir, vamos extrair os recursos do sinal, passo a passo, usando Python, usando a técnica MFCC.
Importe os pacotes necessários, conforme mostrado aqui -
import numpy as np
import matplotlib.pyplot as plt
from scipy.io import wavfile
from python_speech_features import mfcc, logfbank
Agora, leia o arquivo de áudio armazenado. Ele retornará dois valores - a frequência de amostragem e o sinal de áudio. Forneça o caminho do arquivo de áudio onde ele está armazenado.
frequency_sampling, audio_signal = wavfile.read("/Users/admin/audio_file.wav")
Observe que aqui estamos pegando as primeiras 15.000 amostras para análise.
audio_signal = audio_signal[:15000]
Use as técnicas do MFCC e execute o seguinte comando para extrair os recursos do MFCC -
features_mfcc = mfcc(audio_signal, frequency_sampling)
Agora, imprima os parâmetros MFCC, como mostrado -
print('\nMFCC:\nNumber of windows =', features_mfcc.shape[0])
print('Length of each feature =', features_mfcc.shape[1])
Agora, plote e visualize os recursos MFCC usando os comandos fornecidos abaixo -
features_mfcc = features_mfcc.T
plt.matshow(features_mfcc)
plt.title('MFCC')
Nesta etapa, trabalhamos com os recursos do banco de filtros conforme mostrado -
Extraia os recursos do banco de filtros -
filterbank_features = logfbank(audio_signal, frequency_sampling)
Agora, imprima os parâmetros do banco de filtros.
print('\nFilter bank:\nNumber of windows =', filterbank_features.shape[0])
print('Length of each feature =', filterbank_features.shape[1])
Agora, plote e visualize os recursos do banco de filtros.
filterbank_features = filterbank_features.T
plt.matshow(filterbank_features)
plt.title('Filter bank')
plt.show()
Como resultado das etapas acima, você pode observar os seguintes resultados: Figura1 para MFCC e Figura2 para Banco de Filtros
Reconhecimento de palavras faladas
O reconhecimento de fala significa que, quando os humanos estão falando, uma máquina o entende. Aqui, estamos usando a API do Google Speech em Python para fazer isso acontecer. Precisamos instalar os seguintes pacotes para isso -
Pyaudio - Pode ser instalado usando pip install Pyaudio comando.
SpeechRecognition - Este pacote pode ser instalado usando pip install SpeechRecognition.
Google-Speech-API - Pode ser instalado usando o comando pip install google-api-python-client.
Exemplo
Observe o exemplo a seguir para entender sobre o reconhecimento de palavras faladas -
Importe os pacotes necessários conforme mostrado -
import speech_recognition as sr
Crie um objeto como mostrado abaixo -
recording = sr.Recognizer()
Agora o Microphone() o módulo terá a voz como entrada -
with sr.Microphone() as source: recording.adjust_for_ambient_noise(source)
print("Please Say something:")
audio = recording.listen(source)
Agora, a API do Google reconheceria a voz e forneceria a saída.
try:
print("You said: \n" + recording.recognize_google(audio))
except Exception as e:
print(e)
Você pode ver a seguinte saída -
Please Say Something:
You said:
Por exemplo, se você disse tutorialspoint.com, então o sistema o reconhece corretamente da seguinte maneira -
tutorialspoint.com
A pesquisa heurística desempenha um papel fundamental na inteligência artificial. Neste capítulo, você aprenderá em detalhes sobre isso.
Conceito de pesquisa heurística em IA
Heurística é uma regra prática que nos leva à solução provável. A maioria dos problemas de inteligência artificial são de natureza exponencial e têm muitas soluções possíveis. Você não sabe exatamente quais soluções são corretas e verificar todas as soluções seria muito caro.
Assim, o uso de heurísticas restringe a busca por solução e elimina as opções erradas. O método de utilização de heurísticas para conduzir a busca no espaço de busca é denominado Busca Heurística. As técnicas heurísticas são muito úteis porque a pesquisa pode ser aumentada quando você as usa.
Diferença entre pesquisa não informada e informada
Existem dois tipos de estratégias de controle ou técnicas de busca: desinformadas e informadas. Eles são explicados em detalhes conforme fornecidos aqui -
Pesquisa Desinformada
Também é chamada de estratégia de busca cega ou controle cego. Ele é denominado assim porque há informações apenas sobre a definição do problema e nenhuma outra informação extra está disponível sobre os estados. Esse tipo de técnica de pesquisa pesquisaria todo o espaço de estados para obter a solução. Pesquisa em amplitude inicial (BFS) e Pesquisa inicial em profundidade (DFS) são os exemplos de pesquisa não informada.
Pesquisa Informada
Também é chamada de estratégia de busca heurística ou controle heurístico. Tem esse nome porque há algumas informações extras sobre os estados. Essas informações extras são úteis para calcular a preferência entre os nós filhos para explorar e expandir. Haveria uma função heurística associada a cada nó. Best First Search (BFS), A *, Mean e Analysis são os exemplos de pesquisa informada.
Problemas de satisfação de restrição (CSPs)
Restrição significa restrição ou limitação. Em IA, os problemas de satisfação de restrição são os problemas que devem ser resolvidos sob algumas restrições. O foco deve estar em não violar a restrição ao resolver tais problemas. Finalmente, quando chegarmos à solução final, CSP deve obedecer à restrição.
Problema do mundo real resolvido pela satisfação de restrições
As seções anteriores trataram da criação de problemas de satisfação de restrição. Agora, vamos aplicar isso também aos problemas do mundo real. Alguns exemplos de problemas do mundo real resolvidos por satisfação de restrição são os seguintes -
Resolvendo relação algébrica
Com a ajuda do problema de satisfação de restrição, podemos resolver relações algébricas. Neste exemplo, vamos tentar resolver uma relação algébrica simplesa*2 = b. Ele retornará o valor dea e b dentro do intervalo que definiríamos.
Depois de concluir este programa Python, você será capaz de entender os fundamentos da solução de problemas com satisfação de restrições.
Observe que antes de escrever o programa, precisamos instalar o pacote Python chamado python-constraint. Você pode instalá-lo com a ajuda do seguinte comando -
pip install python-constraint
As etapas a seguir mostram um programa Python para resolver a relação algébrica usando satisfação de restrição -
Importe o constraint pacote usando o seguinte comando -
from constraint import *
Agora, crie um objeto de módulo chamado problem() como mostrado abaixo -
problem = Problem()
Agora, defina as variáveis. Observe que aqui temos duas variáveis aeb, e estamos definindo 10 como seu intervalo, o que significa que obtivemos a solução dentro dos primeiros 10 números.
problem.addVariable('a', range(10))
problem.addVariable('b', range(10))
A seguir, defina a restrição particular que queremos aplicar a este problema. Observe que aqui estamos usando a restriçãoa*2 = b.
problem.addConstraint(lambda a, b: a * 2 == b)
Agora, crie o objeto de getSolution() módulo usando o seguinte comando -
solutions = problem.getSolutions()
Por último, imprima a saída usando o seguinte comando -
print (solutions)
Você pode observar a saída do programa acima da seguinte maneira -
[{'a': 4, 'b': 8}, {'a': 3, 'b': 6}, {'a': 2, 'b': 4}, {'a': 1, 'b': 2}, {'a': 0, 'b': 0}]
Quadrado mágico
Um quadrado mágico é um arranjo de números distintos, geralmente inteiros, em uma grade quadrada, onde os números em cada linha e em cada coluna, e os números na diagonal, somam todos o mesmo número chamado de "constante mágica" .
A seguir está uma execução gradual de código Python simples para gerar quadrados mágicos -
Defina uma função chamada magic_square, como mostrado abaixo -
def magic_square(matrix_ms):
iSize = len(matrix_ms[0])
sum_list = []
O código a seguir mostra o código para a vertical dos quadrados -
for col in range(iSize):
sum_list.append(sum(row[col] for row in matrix_ms))
O código a seguir mostra o código para o horizontal dos quadrados -
sum_list.extend([sum (lines) for lines in matrix_ms])
O código a seguir mostra o código para a horizontal dos quadrados -
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
Agora, dê o valor da matriz e verifique a saída -
print(magic_square([[1,2,3], [4,5,6], [7,8,9]]))
Você pode observar que a saída seria False como a soma não corresponde ao mesmo número.
print(magic_square([[3,9,2], [3,5,7], [9,1,6]]))
Você pode observar que a saída seria True como a soma é o mesmo número, isto é 15 aqui.
Os jogos são jogados com uma estratégia. Cada jogador ou equipe faria uma estratégia antes de iniciar o jogo e eles teriam que mudar ou construir uma nova estratégia de acordo com a (s) situação (ões) atual (is) no jogo.
Algoritmos de Pesquisa
Você terá que considerar os jogos de computador também com a mesma estratégia acima. Observe que os algoritmos de pesquisa são aqueles que descobrem a estratégia em jogos de computador.
Como funciona
O objetivo dos algoritmos de busca é encontrar o conjunto ideal de jogadas para que possam chegar ao destino final e vencer. Esses algoritmos usam o conjunto de condições vencedoras, diferentes para cada jogo, para encontrar os melhores movimentos.
Visualize um jogo de computador como uma árvore. Sabemos que a árvore tem nós. Começando pela raiz, podemos chegar ao nó vencedor final, mas com movimentos ótimos. Esse é o trabalho dos algoritmos de busca. Cada nó dessa árvore representa um estado futuro. Os algoritmos de busca buscam nesta árvore para tomar decisões em cada etapa ou nó do jogo.
Pesquisa Combinacional
A principal desvantagem de usar algoritmos de pesquisa é que eles são exaustivos por natureza, razão pela qual exploram todo o espaço de pesquisa para encontrar a solução que leva ao desperdício de recursos. Seria mais complicado se esses algoritmos precisassem pesquisar todo o espaço de pesquisa para encontrar a solução final.
Para eliminar esse tipo de problema, podemos utilizar a busca combinacional que utiliza a heurística para explorar o espaço de busca e reduz seu tamanho eliminando os possíveis movimentos errados. Conseqüentemente, esses algoritmos podem economizar recursos. Alguns dos algoritmos que usam heurística para pesquisar o espaço e economizar recursos são discutidos aqui -
Algoritmo Minimax
É a estratégia de busca combinacional que utiliza heurística para agilizar a estratégia de busca. O conceito de estratégia Minimax pode ser entendido com o exemplo dos jogos de dois jogadores, em que cada jogador tenta prever o próximo movimento do adversário e tentar minimizar essa função. Além disso, para ganhar, o jogador sempre tenta maximizar sua função com base na situação atual.
A heurística desempenha um papel importante em estratégias como o Minimax. Cada nó da árvore teria uma função heurística associada a ele. Com base nessa heurística, ele tomará a decisão de fazer um movimento em direção ao nó que mais os beneficiaria.
Poda alfa-beta
Um grande problema com o algoritmo Minimax é que ele pode explorar aquelas partes da árvore que são irrelevantes, levando ao desperdício de recursos. Portanto, deve haver uma estratégia para decidir qual parte da árvore é relevante e qual é irrelevante e deixar a parte irrelevante inexplorada. A poda alfa-beta é um desses tipos de estratégia.
O objetivo principal do algoritmo de poda Alfa-Beta é evitar a busca por partes da árvore que não têm solução. O conceito principal de poda alfa-beta é usar dois limites chamadosAlpha, o limite inferior máximo e Beta, o limite superior mínimo. Esses dois parâmetros são os valores que restringem o conjunto de soluções possíveis. Ele compara o valor do nó atual com o valor dos parâmetros alfa e beta, de forma que possa mover para a parte da árvore que tem a solução e descartar o resto.
Algoritmo Negamax
Este algoritmo não é diferente do algoritmo Minimax, mas tem uma implementação mais elegante. A principal desvantagem de usar o algoritmo Minimax é que precisamos definir duas funções heurísticas diferentes. A conexão entre essas heurísticas é que, quanto melhor o estado de um jogo para um jogador, pior para o outro jogador. No algoritmo Negamax, o mesmo trabalho de duas funções heurísticas é feito com o auxílio de uma única função heurística.
Construindo Bots para Jogar
Para construir bots para jogar jogos de dois jogadores em IA, precisamos instalar o easyAIbiblioteca. É uma estrutura de inteligência artificial que fornece todas as funcionalidades para construir jogos para dois jogadores. Você pode baixá-lo com a ajuda do seguinte comando -
pip install easyAI
Um bot para jogar a última moeda em pé
Neste jogo, haveria uma pilha de moedas. Cada jogador deve pegar um certo número de moedas dessa pilha. O objetivo do jogo é evitar tirar a última moeda da pilha. Estaremos usando a classeLastCoinStanding herdado de TwoPlayersGame classe do easyAIbiblioteca. O código a seguir mostra o código Python para este jogo -
Importe os pacotes necessários conforme mostrado -
from easyAI import TwoPlayersGame, id_solve, Human_Player, AI_Player
from easyAI.AI import TT
Agora, herde a classe do TwoPlayerGame classe para lidar com todas as operações do jogo -
class LastCoin_game(TwoPlayersGame):
def __init__(self, players):
Agora, defina os jogadores e o jogador que vai iniciar o jogo.
self.players = players
self.nplayer = 1
Agora, defina o número de moedas no jogo, aqui estamos usando 15 moedas para o jogo.
self.num_coins = 15
Defina o número máximo de moedas que um jogador pode pegar em uma jogada.
self.max_coins = 4
Agora, existem algumas coisas para definir, conforme mostrado no código a seguir. Defina movimentos possíveis.
def possible_moves(self):
return [str(a) for a in range(1, self.max_coins + 1)]
Defina a remoção das moedas
def make_move(self, move):
self.num_coins -= int(move)
Defina quem pegou a última moeda.
def win_game(self):
return self.num_coins <= 0
Defina quando parar o jogo, ou seja, quando alguém ganhar.
def is_over(self):
return self.win()
Defina como calcular a pontuação.
def score(self):
return 100 if self.win_game() else 0
Defina o número de moedas restantes na pilha.
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
Resolvendo o jogo com o seguinte bloco de código -
r, d, m = id_solve(LastCoin_game,
range(2, 20), win_score=100, tt=tt)
print(r, d, m)
Decidindo quem vai começar o jogo
game = LastCoin_game([AI_Player(tt), Human_Player()])
game.play()
Você pode encontrar a seguinte saída e um jogo simples deste jogo -
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
Um bot para jogar jogo da velha
Tic-Tac-Toe é muito familiar e um dos jogos mais populares. Vamos criar este jogo usando oeasyAIbiblioteca em Python. O código a seguir é o código Python deste jogo -
Importe os pacotes como mostrado -
from easyAI import TwoPlayersGame, AI_Player, Negamax
from easyAI.Player import Human_Player
Herdar a classe do TwoPlayerGame classe para lidar com todas as operações do jogo -
class TicTacToe_game(TwoPlayersGame):
def __init__(self, players):
Agora, defina os jogadores e o jogador que vai iniciar o jogo -
self.players = players
self.nplayer = 1
Defina o tipo de placa -
self.board = [0] * 9
Agora, existem algumas coisas para definir a seguir -
Definir movimentos possíveis
def possible_moves(self):
return [x + 1 for x, y in enumerate(self.board) if y == 0]
Defina a jogada de um jogador -
def make_move(self, move):
self.board[int(move) - 1] = self.nplayer
Para aumentar a IA, defina quando um jogador faz um movimento -
def umake_move(self, move):
self.board[int(move) - 1] = 0
Defina a condição de perda em que um oponente tem três em linha
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])
Defina uma verificação para o fim do jogo
def is_over(self):
return (self.possible_moves() == []) or self.condition_for_lose()
Mostra a posição atual dos jogadores no jogo
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 as pontuações.
def scoring(self):
return -100 if self.condition_for_lose() else 0
Defina o método principal para definir o algoritmo e iniciar o jogo -
if __name__ == "__main__":
algo = Negamax(7)
TicTacToe_game([Human_Player(), AI_Player(algo)]).play()
Você pode ver a saída a seguir e uma simples execução deste jogo -
. . .
. . .
. . .
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 .
As redes neurais são dispositivos de computação paralela que são uma tentativa de fazer um modelo computacional do cérebro. O objetivo principal é desenvolver um sistema para realizar várias tarefas computacionais mais rapidamente do que os sistemas tradicionais. Essas tarefas incluem Reconhecimento e Classificação de Padrões, Aproximação, Otimização e Clustering de Dados.
O que são Redes Neurais Artificiais (RNA)
A rede neural artificial (RNA) é um sistema de computação eficiente cujo tema central é emprestado da analogia das redes neurais biológicas. As RNAs também são chamadas de Sistemas Neurais Artificiais, Sistemas de Processamento Distribuído Paralelo e Sistemas Conexionistas. A RNA adquire uma grande coleção de unidades que são interconectadas em algum padrão para permitir a comunicação entre elas. Essas unidades, também chamadas denodes ou neurons, são processadores simples que operam em paralelo.
Cada neurônio está conectado com outro neurônio por meio de um connection link. Cada link de conexão está associado a um peso contendo as informações sobre o sinal de entrada. Esta é a informação mais útil para os neurônios resolverem um problema específico porque oweightgeralmente excita ou inibe o sinal que está sendo comunicado. Cada neurônio está tendo seu estado interno que é chamadoactivation signal. Os sinais de saída, que são produzidos após combinar os sinais de entrada e a regra de ativação, podem ser enviados para outras unidades.
Se você deseja estudar redes neurais em detalhes, siga o link - Rede Neural Artificial .
Instalando Pacotes Úteis
Para criar redes neurais em Python, podemos usar um pacote poderoso para redes neurais chamado NeuroLab. É uma biblioteca de algoritmos básicos de redes neurais com configurações de rede flexíveis e algoritmos de aprendizagem para Python. Você pode instalar este pacote com a ajuda do seguinte comando no prompt de comando -
pip install NeuroLab
Se você estiver usando o ambiente Anaconda, use o seguinte comando para instalar o NeuroLab -
conda install -c labfabulous neurolab
Construindo Redes Neurais
Nesta seção, vamos construir algumas redes neurais em Python usando o pacote NeuroLab.
Classificador baseado em Perceptron
Perceptrons são os blocos de construção da ANN. Se você quiser saber mais sobre o Perceptron, pode seguir o link - artificial_neural_network
A seguir está uma execução passo a passo do código Python para a construção de um classificador baseado em perceptron de rede neural simples -
Importe os pacotes necessários conforme mostrado -
import matplotlib.pyplot as plt
import neurolab as nl
Insira os valores de entrada. Observe que é um exemplo de aprendizagem supervisionada, portanto, você também terá que fornecer valores-alvo.
input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]
Crie a rede com 2 entradas e 1 neurônio -
net = nl.net.newp([[0, 1],[0, 1]], 1)
Agora, treine a rede. Aqui, estamos usando a regra Delta para treinamento.
error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)
Agora, visualize a saída e plote o gráfico -
plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()
Você pode ver o gráfico a seguir mostrando o progresso do treinamento usando a métrica de erro -
Redes Neurais de Camada Única
Neste exemplo, estamos criando uma rede neural de camada única que consiste em neurônios independentes agindo nos dados de entrada para produzir a saída. Observe que estamos usando o arquivo de texto chamadoneural_simple.txt como nossa entrada.
Importe os pacotes úteis como mostrado -
import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl
Carregue o conjunto de dados da seguinte forma -
input_data = np.loadtxt(“/Users/admin/neural_simple.txt')
A seguir estão os dados que vamos usar. Observe que, nesses dados, as duas primeiras colunas são os recursos e as duas últimas colunas são os rótulos.
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. ]])
Agora, separe essas quatro colunas em 2 colunas de dados e 2 rótulos -
data = input_data[:, 0:2]
labels = input_data[:, 2:]
Plote os dados de entrada usando os seguintes comandos -
plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')
Agora, defina os valores mínimo e máximo para cada dimensão, conforme mostrado aqui -
dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()
Em seguida, defina o número de neurônios na camada de saída da seguinte forma -
nn_output_layer = labels.shape[1]
Agora, defina uma rede neural de camada única -
dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)
Treine a rede neural com número de épocas e taxa de aprendizagem, conforme mostrado -
error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)
Agora, visualize e plote o progresso do treinamento usando os seguintes comandos -
plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()
Agora, use os pontos de dados de teste no classificador acima -
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])
Você pode encontrar os resultados do teste conforme mostrado aqui -
[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]
Você pode ver os seguintes gráficos como a saída do código discutido até agora -
Redes Neurais Multi-Camadas
Neste exemplo, estamos criando uma rede neural multicamadas que consiste em mais de uma camada para extrair os padrões subjacentes nos dados de treinamento. Esta rede neural multicamadas funcionará como um regressor. Vamos gerar alguns pontos de dados com base na equação: y = 2x 2 +8.
Importe os pacotes necessários conforme mostrado -
import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl
Gere alguns pontos de dados com base na equação mencionada acima -
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)
Agora, remodele este conjunto de dados da seguinte maneira -
data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)
Visualize e plote o conjunto de dados de entrada usando os seguintes comandos -
plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')
Agora, construa a rede neural com duas camadas ocultas com neurolab com ten neurônios na primeira camada oculta, six na segunda camada oculta e one na camada de saída.
neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])
Agora use o algoritmo de treinamento gradiente -
neural_net.trainf = nl.train.train_gd
Agora treine a rede com o objetivo de aprender sobre os dados gerados acima -
error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)
Agora, execute as redes neurais nos pontos de dados de treinamento -
output = neural_net.sim(data)
y_pred = output.reshape(num_points)
Agora, plotagem e tarefa de visualização -
plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')
Agora estaremos traçando a saída real versus a prevista -
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_dense.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 dos comandos acima, você pode observar os gráficos conforme mostrado abaixo -
Neste capítulo, você aprenderá em detalhes sobre o aprendizado de reforço de conceitos em IA com Python.
Noções básicas de aprendizagem por reforço
Esse tipo de aprendizado é usado para reforçar ou fortalecer a rede a partir de informações críticas. Ou seja, uma rede sendo treinada em aprendizagem por reforço, recebe algum feedback do ambiente. No entanto, o feedback é avaliativo e não instrutivo como no caso da aprendizagem supervisionada. Com base nesse feedback, a rede realiza os ajustes dos pesos para obter no futuro melhores informações críticas.
Este processo de aprendizado é semelhante ao aprendizado supervisionado, mas podemos ter muito menos informações. A figura a seguir apresenta o diagrama de blocos da aprendizagem por reforço -
Blocos de construção: ambiente e agente
Ambiente e Agente são os principais blocos de construção do aprendizado por reforço em IA. Esta seção os discute em detalhes -
Agente
Um agente é qualquer coisa que pode perceber seu ambiente por meio de sensores e atuar nesse ambiente por meio de efetores.
UMA human agent tem órgãos sensoriais, como olhos, ouvidos, nariz, língua e pele paralelos aos sensores, e outros órgãos, como mãos, pernas, boca, para efetores.
UMA robotic agent substitui câmeras e telêmetros infravermelhos para os sensores e vários motores e atuadores para efetores.
UMA software agent codificou cadeias de bits como seus programas e ações.
Terminologia do Agente
Os termos a seguir são usados com mais frequência na aprendizagem por reforço em IA -
Performance Measure of Agent - São os critérios que determinam o grau de sucesso de um agente.
Behavior of Agent - É a ação que o agente realiza após uma determinada sequência de percepções.
Percept - São as entradas perceptivas do agente em uma determinada instância.
Percept Sequence - É a história de tudo que um agente percebeu até hoje.
Agent Function - É um mapa da sequência de preceitos a uma ação.
Meio Ambiente
Alguns programas operam inteiramente artificial environment confinado à entrada do teclado, banco de dados, sistemas de arquivos de computador e saída de caracteres em uma tela.
Em contraste, alguns agentes de software, como robôs de software ou softbots, existem em domínios de softbot ricos e ilimitados. O simulador tem umvery detailed, e complex environment. O agente de software precisa escolher entre uma grande variedade de ações em tempo real.
Por exemplo, um softbot projetado para verificar as preferências online do cliente e exibir itens interessantes para o cliente trabalha no real bem como um artificial meio Ambiente.
Propriedades do ambiente
O ambiente tem propriedades múltiplas, conforme discutido abaixo -
Discrete/Continuous- Se houver um número limitado de estados distintos e claramente definidos do ambiente, o ambiente é discreto, caso contrário, é contínuo. Por exemplo, o xadrez é um ambiente discreto e dirigir é um ambiente contínuo.
Observable/Partially Observable- Se é possível determinar o estado completo do ambiente em cada ponto do tempo a partir das percepções, ele é observável; caso contrário, é apenas parcialmente observável.
Static/Dynamic- Se o ambiente não muda enquanto um agente está agindo, então ele é estático; caso contrário, é dinâmico.
Single agent/Multiple agents - O ambiente pode conter outros agentes que podem ser do mesmo tipo ou de tipo diferente do agente.
Accessible/Inaccessible- Se o aparato sensorial do agente pode ter acesso ao estado completo do ambiente, então o ambiente é acessível a esse agente; caso contrário, fica inacessível.
Deterministic/Non-deterministic- Se o próximo estado do ambiente for completamente determinado pelo estado atual e pelas ações do agente, então o ambiente é determinístico; caso contrário, é não determinístico.
Episodic/Non-episodic- Em um ambiente episódico, cada episódio consiste no agente percebendo e então agindo. A qualidade de sua ação depende apenas do episódio em si. Os episódios subsequentes não dependem das ações dos episódios anteriores. Ambientes episódicos são muito mais simples porque o agente não precisa pensar no futuro.
Construindo um ambiente com Python
Para a construção do agente de aprendizagem por reforço, estaremos usando o OpenAI Gym pacote que pode ser instalado com a ajuda do seguinte comando -
pip install gym
Existem vários ambientes no ginásio OpenAI que podem ser usados para vários fins. Poucos deles sãoCartpole-v0, Hopper-v1, e MsPacman-v0. Eles requerem motores diferentes. A documentação detalhada deOpenAI Gym pode ser encontrado em https://gym.openai.com/docs/#environments.
O código a seguir mostra um exemplo de código Python para o ambiente cartpole-v0 -
import gym
env = gym.make('CartPole-v0')
env.reset()
for _ in range(1000):
env.render()
env.step(env.action_space.sample())
Você pode construir outros ambientes de maneira semelhante.
Construindo um agente de aprendizagem com Python
Para a construção do agente de aprendizagem por reforço, estaremos usando o OpenAI Gym pacote como mostrado -
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 o mastro pode se equilibrar.
Este capítulo discute algoritmos genéticos de IA em detalhes.
O que são algoritmos genéticos?
Algoritmos Genéticos (AGs) são algoritmos de pesquisa baseados nos conceitos de seleção natural e genética. Os AGs são um subconjunto de um ramo muito maior da computação, conhecido como Computação Evolutiva.
Os AGs foram desenvolvidos por John Holland e seus alunos e colegas da Universidade de Michigan, principalmente David E. Goldberg. Desde então, ele foi testado em vários problemas de otimização com alto grau de sucesso.
Em GAs, temos um conjunto de soluções possíveis para o problema fornecido. Essas soluções, então, sofrem recombinação e mutação (como na genética natural), produzem novos filhos e o processo se repete por várias gerações. Cada indivíduo (ou solução candidata) recebe um valor de aptidão (com base em seu valor de função objetivo) e os indivíduos mais aptos recebem uma chance maior de acasalar e produzirfitterindivíduos. Isso está de acordo com a Teoria Darwiniana deSurvival of the Fittest.
Assim, mantém evolving melhores indivíduos ou soluções ao longo das gerações, até atingir um critério de parada.
Os algoritmos genéticos são suficientemente aleatórios por natureza, mas têm um desempenho muito melhor do que a pesquisa local aleatória (onde apenas tentamos soluções aleatórias, rastreando as melhores até agora), pois também exploram informações históricas.
Como usar o GA para problemas de otimização?
A otimização é uma ação de tornar o design, a situação, o recurso e o sistema tão eficazes quanto possível. O diagrama de blocos a seguir mostra o processo de otimização -
Estágios do mecanismo de GA para o processo de otimização
A seguir está uma sequência de etapas do mecanismo de GA quando usado para otimização de problemas.
Etapa 1 - Gere a população inicial aleatoriamente.
Etapa 2 - Selecione a solução inicial com os melhores valores de adequação.
Etapa 3 - recombinar as soluções selecionadas usando operadores de mutação e crossover.
Etapa 4 - Insira uma prole na população.
Passo 5 - Agora, se a condição de parada for atendida, retorne a solução com seu melhor valor de aptidão. Caso contrário, vá para a etapa 2.
Instalando os pacotes necessários
Para resolver o problema usando Algoritmos Genéticos em Python, vamos usar um pacote poderoso para GA chamado DEAP. É uma biblioteca de nova estrutura de computação evolutiva para prototipagem rápida e teste de ideias. Podemos instalar este pacote com a ajuda do seguinte comando no prompt de comando -
pip install deap
Se você estiver usando anaconda ambiente, o seguinte comando pode ser usado para instalar o deap -
conda install -c conda-forge deap
Implementando Soluções usando Algoritmos Genéticos
Esta seção explica a implementação de soluções usando Algoritmos Genéticos.
Gerando padrões de bits
O exemplo a seguir mostra como gerar uma string de bits que conteria 15 unidades, com base no One Max problema.
Importe os pacotes necessários conforme mostrado -
import random
from deap import base, creator, tools
Defina a função de avaliação. É o primeiro passo para criar um algoritmo genético.
def eval_func(individual):
target_sum = 15
return len(individual) - abs(sum(individual) - target_sum),
Agora, crie a caixa de ferramentas com os parâmetros certos -
def create_toolbox(num_bits):
creator.create("FitnessMax", base.Fitness, weights=(1.0,))
creator.create("Individual", list, fitness=creator.FitnessMax)
Inicialize a caixa de ferramentas
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 o operador de avaliação -
toolbox.register("evaluate", eval_func)
Agora, registre o operador de crossover -
toolbox.register("mate", tools.cxTwoPoint)
Registre um operador de mutação -
toolbox.register("mutate", tools.mutFlipBit, indpb = 0.05)
Defina o operador para reprodução -
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')
Avalie toda a população -
fitnesses = list(map(toolbox.evaluate, population))
for ind, fit in zip(population, fitnesses):
ind.fitness.values = fit
print('\nEvaluated', len(population), 'individuals')
Crie e repita através das gerações -
for g in range(num_generations):
print("\n- Generation", g)
Selecionando os indivíduos da próxima geração -
offspring = toolbox.select(population, len(population))
Agora, clone os indivíduos selecionados -
offspring = list(map(toolbox.clone, offspring))
Aplicar crossover e mutação na prole -
for child1, child2 in zip(offspring[::2], offspring[1::2]):
if random.random() < probab_crossing:
toolbox.mate(child1, child2)
Exclua o valor de aptidão da criança
del child1.fitness.values
del child2.fitness.values
Agora, aplique a mutação -
for mutant in offspring:
if random.random() < probab_mutating:
toolbox.mutate(mutant)
del mutant.fitness.values
Avalie os indivíduos com aptidão invá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')
Agora, substitua a população por indivíduos da próxima geração -
population[:] = offspring
Imprima as estatísticas para as gerações atuais -
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 o 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 regressão de símbolo
É um dos problemas mais conhecidos da programação genética. Todos os problemas de regressão simbólica usam uma distribuição de dados arbitrária e tentam ajustar os dados mais precisos com uma fórmula simbólica. Normalmente, uma medida como o RMSE (Root Mean Square Error) é usada para medir a aptidão de um indivíduo. É um problema clássico de regressor e aqui estamos usando a equação5x3-6x2+8x=1. Precisamos seguir todas as etapas conforme seguidas no exemplo acima, mas a parte principal seria criar os conjuntos primitivos porque eles são os blocos de construção para os indivíduos para que a avaliação possa começar. Aqui estaremos usando o conjunto clássico de primitivas.
O código Python a seguir explica isso em detalhes -
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)
Observe que todas as etapas básicas são iguais às usadas durante a geração de padrões de bits. Este programa nos dará a saída como min, max, std (desvio padrão) após 10 números de gerações.
A visão computacional se preocupa com a modelagem e a replicação da visão humana usando software e hardware de computador. Neste capítulo, você aprenderá em detalhes sobre isso.
Visão Computacional
A visão computacional é uma disciplina que estuda como reconstruir, interromper e compreender uma cena 3D a partir de suas imagens 2D, em termos das propriedades da estrutura presente na cena.
Hierarquia de visão computacional
A visão computacional é dividida em três categorias básicas como segue -
Low-level vision - Inclui imagem de processo para extração de recursos.
Intermediate-level vision - Inclui reconhecimento de objetos e interpretação de cenas 3D
High-level vision - Inclui a descrição conceitual de uma cena como atividade, intenção e comportamento.
Visão Computacional Vs Processamento de Imagens
O processamento de imagens estuda a transformação de imagem em imagem. A entrada e a saída do processamento de imagem são imagens.
A visão computacional é a construção de descrições explícitas e significativas de objetos físicos a partir de sua imagem. A saída da visão computacional é uma descrição ou interpretação de estruturas em cena 3D.
Formulários
A visão computacional encontra aplicações nos seguintes campos -
Robotics
Localização - determina a localização do robô automaticamente
Navigation
Evitar obstáculos
Montagem (peg-in-hole, soldagem, pintura)
Manipulação (por exemplo, robô manipulador PUMA)
Human Robot Interaction (HRI): robótica inteligente para interagir e servir as pessoas
Medicine
Classificação e detecção (por exemplo, lesão ou classificação de células e detecção de tumor)
Segmentação 2D / 3D
Reconstrução 3D de órgãos humanos (ressonância magnética ou ultrassom)
Cirurgia robótica guiada pela visão
Security
- Biometria (íris, impressão digital, reconhecimento facial)
- Vigilância - detecção de certas atividades ou comportamentos suspeitos
Transportation
- Veículo autônomo
- Segurança, por exemplo, monitoramento de vigilância do motorista
Industrial Automation Application
- Inspeção industrial (detecção de defeito)
- Assembly
- Leitura do código de barras e etiqueta da embalagem
- Classificação de objetos
- Compreensão de documentos (por exemplo, OCR)
Instalando Pacotes Úteis
Para visão computacional com Python, você pode usar uma biblioteca popular chamada OpenCV(Open Source Computer Vision). É uma biblioteca de funções de programação voltada principalmente para a visão computacional em tempo real. Ele é escrito em C ++ e sua interface principal é em C ++. Você pode instalar este pacote com a ajuda do seguinte comando -
pip install opencv_python-X.X-cp36-cp36m-winX.whl
Aqui, X representa a versão do Python instalada em sua máquina, bem como o win32 ou 64 bits que você tem.
Se você estiver usando o anaconda ambiente e, em seguida, use o seguinte comando para instalar o OpenCV -
conda install -c conda-forge opencv
Ler, escrever e exibir uma imagem
A maioria dos aplicativos de currículo precisa obter as imagens como entrada e produzi-las como saída. Nesta seção, você aprenderá a ler e gravar arquivos de imagem com a ajuda das funções fornecidas pelo OpenCV.
Funções OpenCV para ler, mostrar, escrever um arquivo de imagem
O OpenCV fornece as seguintes funções para esta finalidade -
imread() function- Esta é a função de leitura de uma imagem. OpenCV imread () suporta vários formatos de imagem como PNG, JPEG, JPG, TIFF, etc.
imshow() function- Esta é a função para mostrar uma imagem em uma janela. A janela se ajusta automaticamente ao tamanho da imagem. OpenCV imshow () suporta vários formatos de imagem como PNG, JPEG, JPG, TIFF, etc.
imwrite() function- Esta é a função para escrever uma imagem. OpenCV imwrite () suporta vários formatos de imagem como PNG, JPEG, JPG, TIFF, etc.
Exemplo
Este exemplo mostra o código Python para ler uma imagem em um formato - exibindo-a em uma janela e escrevendo a mesma imagem em outro formato. Considere as etapas mostradas abaixo -
Importe o pacote OpenCV conforme mostrado -
import cv2
Agora, para ler uma imagem particular, use a função imread () -
image = cv2.imread('image_flower.jpg')
Para mostrar a imagem, use o imshow()função. O nome da janela na qual você pode ver a imagem seriaimage_flower.
cv2.imshow('image_flower',image)
cv2.destroyAllwindows()
Agora, podemos escrever a mesma imagem em outro formato, digamos .png, usando a função imwrite () -
cv2.imwrite('image_flower.png',image)
A saída True significa que a imagem foi gravada com sucesso como um arquivo .png também na mesma pasta.
True
Nota - A função destroyallWindows () simplesmente destrói todas as janelas que criamos.
Conversão de Espaço de Cor
No OpenCV, as imagens não são armazenadas usando a cor RGB convencional, mas sim na ordem inversa, ou seja, na ordem BGR. Portanto, o código de cor padrão ao ler uma imagem é BGR. ocvtColor() função de conversão de cores para converter a imagem de um código de cor para outro.
Exemplo
Considere este exemplo para converter a imagem de BGR em tons de cinza.
Importe o OpenCV pacote como mostrado -
import cv2
Agora, para ler uma imagem particular, use a função imread () -
image = cv2.imread('image_flower.jpg')
Agora, se virmos esta imagem usando imshow() função, então podemos ver que esta imagem está em BGR.
cv2.imshow('BGR_Penguins',image)
Agora usa cvtColor() função para converter esta imagem em tons de cinza.
image = cv2.cvtColor(image,cv2.COLOR_BGR2GRAY)
cv2.imshow('gray_penguins',image)
Detecção de Borda
Os humanos, depois de ver um esboço tosco, podem reconhecer facilmente muitos tipos de objetos e suas poses. É por isso que as arestas desempenham um papel importante na vida dos humanos, bem como nas aplicações da visão computacional. OpenCV fornece uma função muito simples e útil chamadaCanny()para detectar as bordas.
Exemplo
O exemplo a seguir mostra a identificação clara das bordas.
Importe o pacote OpenCV como mostrado -
import cv2
import numpy as np
Agora, para ler uma imagem específica, use o imread() função.
image = cv2.imread('Penguins.jpg')
Agora, use o Canny () função para detectar as bordas da imagem já lida.
cv2.imwrite(‘edges_Penguins.jpg’,cv2.Canny(image,200,300))
Agora, para mostrar a imagem com bordas, use a função imshow ().
cv2.imshow(‘edges’, cv2.imread(‘‘edges_Penguins.jpg’))
Este programa Python criará uma imagem chamada edges_penguins.jpg com detecção de borda.
Detecção de rosto
A detecção de rosto é uma das aplicações fascinantes da visão computacional, o que a torna mais realista e futurística. O OpenCV possui um recurso integrado para realizar a detecção de rosto. Vamos usar oHaar classificador em cascata para detecção de rosto.
Dados Haar Cascade
Precisamos de dados para usar o classificador em cascata Haar. Você pode encontrar esses dados em nosso pacote OpenCV. Depois de instalar o OpenCv, você pode ver o nome da pastahaarcascades. Haveria arquivos .xml para aplicativos diferentes. Agora, copie todos eles para uso diferente e cole em uma nova pasta no projeto atual.
Example
A seguir está o código Python usando Haar Cascade para detectar a face de Amitabh Bachan mostrado na imagem a seguir -
Importe o OpenCV pacote como mostrado -
import cv2
import numpy as np
Agora, use o HaarCascadeClassifier para detectar rosto -
face_detection=
cv2.CascadeClassifier('D:/ProgramData/cascadeclassifier/
haarcascade_frontalface_default.xml')
Agora, para ler uma imagem específica, use o imread() função -
img = cv2.imread('AB.jpg')
Agora, converta-o em tons de cinza porque ele aceitaria imagens cinza -
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
Agora, usando face_detection.detectMultiScale, realizar detecção de rosto real
faces = face_detection.detectMultiScale(gray, 1.3, 5)
Agora, desenhe um retângulo ao redor de todo o rosto -
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 criará uma imagem chamada Face_AB.jpg com detecção de rosto como mostrado
Detecção de olhos
A detecção ocular é outra aplicação fascinante da visão computacional, que a torna mais realista e futurística. O OpenCV possui um recurso integrado para realizar a detecção do olho. Vamos usar oHaar cascade classificador para detecção de olhos.
Exemplo
O exemplo a seguir fornece o código Python usando Haar Cascade para detectar a face de Amitabh Bachan dada na imagem a seguir -
Importe o pacote OpenCV como mostrado -
import cv2
import numpy as np
Agora, use o HaarCascadeClassifier para detectar rosto -
eye_cascade = cv2.CascadeClassifier('D:/ProgramData/cascadeclassifier/haarcascade_eye.xml')
Agora, para ler uma imagem específica, use o imread() função
img = cv2.imread('AB_Eye.jpg')
Agora, converta-o em tons de cinza porque ele aceitaria imagens cinza -
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
Agora com a ajuda de eye_cascade.detectMultiScale, realizar detecção de rosto real
eyes = eye_cascade.detectMultiScale(gray, 1.03, 5)
Agora, desenhe um retângulo ao redor de todo o rosto -
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 Python criará uma imagem chamada Eye_AB.jpg com detecção de olho como mostrado -
Rede Neural Artificial (RNA) é um sistema de computação eficiente, cujo tema central é emprestado da analogia das redes neurais biológicas. As redes neurais são um tipo de modelo de aprendizado de máquina. Em meados da década de 1980 e no início da década de 1990, muitos avanços arquitetônicos importantes foram feitos em redes neurais. Neste capítulo, você aprenderá mais sobre Deep Learning, uma abordagem de IA.
O aprendizado profundo emergiu de um crescimento computacional explosivo de uma década como um sério competidor no campo. Assim, o aprendizado profundo é um tipo particular de aprendizado de máquina cujos algoritmos são inspirados na estrutura e função do cérebro humano.
Aprendizado de máquina x Aprendizado profundo
O aprendizado profundo é a técnica de aprendizado de máquina mais poderosa atualmente. É tão poderoso porque eles aprendem a melhor maneira de representar o problema enquanto aprendem como resolvê-lo. Uma comparação entre aprendizado profundo e aprendizado de máquina é fornecida abaixo -
Dependência de Dados
O primeiro ponto de diferença é baseado no desempenho de DL e ML quando a escala de dados aumenta. Quando os dados são grandes, os algoritmos de aprendizado profundo funcionam muito bem.
Dependência de máquina
Algoritmos de aprendizado profundo precisam de máquinas de última geração para funcionarem perfeitamente. Por outro lado, os algoritmos de aprendizado de máquina também podem funcionar em máquinas de baixo custo.
Extração de característica
Algoritmos de aprendizado profundo podem extrair recursos de alto nível e tentar aprender com os mesmos também. Por outro lado, um especialista é necessário para identificar a maioria dos recursos extraídos pelo aprendizado de máquina.
Tempo de Execução
O tempo de execução depende dos vários parâmetros usados em um algoritmo. O aprendizado profundo tem mais parâmetros do que algoritmos de aprendizado de máquina. Portanto, o tempo de execução de algoritmos DL, principalmente o tempo de treinamento, é muito mais do que algoritmos ML. Mas o tempo de teste dos algoritmos DL é menor do que os algoritmos ML.
Abordagem para resolução de problemas
O aprendizado profundo resolve o problema de ponta a ponta, enquanto o aprendizado de máquina usa a maneira tradicional de resolver o problema, ou seja, dividindo-o em partes.
Rede Neural Convolucional (CNN)
As redes neurais convolucionais são iguais às redes neurais comuns porque também são feitas de neurônios com pesos e tendências aprendíveis. As redes neurais comuns ignoram a estrutura dos dados de entrada e todos os dados são convertidos em uma matriz 1-D antes de alimentá-los na rede. Este processo se adapta aos dados regulares, no entanto, se os dados contiverem imagens, o processo pode ser complicado.
A CNN resolve esse problema facilmente. Leva em consideração a estrutura 2D das imagens ao processá-las, o que permite extrair as propriedades específicas das imagens. Dessa forma, o objetivo principal das CNNs é ir dos dados brutos da imagem na camada de entrada para a classe correta na camada de saída. A única diferença entre um NNs e CNNs comuns está no tratamento dos dados de entrada e no tipo de camadas.
Visão geral da arquitetura das CNNs
Arquitetonicamente, as redes neurais comuns recebem uma entrada e a transformam por meio de uma série de camadas ocultas. Cada camada é conectada à outra camada com a ajuda de neurônios. A principal desvantagem das redes neurais comuns é que elas não são bem dimensionadas para imagens completas.
A arquitetura das CNNs possui neurônios dispostos em 3 dimensões chamadas largura, altura e profundidade. Cada neurônio na camada atual é conectado a um pequeno pedaço da saída da camada anterior. É semelhante a sobrepor um×filtro na imagem de entrada. UsaMfiltros para ter certeza de como obter todos os detalhes. EstesM filtros são extratores de recursos que extraem recursos como bordas, cantos, etc.
Camadas usadas para construir CNNs
As seguintes camadas são usadas para construir CNNs -
Input Layer - Aceita os dados brutos da imagem como estão.
Convolutional Layer- Esta camada é o bloco de construção central das CNNs que faz a maioria dos cálculos. Esta camada calcula as convoluções entre os neurônios e os vários patches na entrada.
Rectified Linear Unit Layer- Aplica uma função de ativação à saída da camada anterior. Ele adiciona não linearidade à rede para que possa generalizar bem para qualquer tipo de função.
Pooling Layer- O pooling nos ajuda a manter apenas as partes importantes à medida que progredimos na rede. A camada de pooling opera independentemente em cada fatia de profundidade da entrada e a redimensiona espacialmente. Ele usa a função MAX.
Fully Connected layer/Output layer - Esta camada calcula as pontuações de saída na última camada. A saída resultante é do tamanho×× , onde L é o número de classes do conjunto de dados de treinamento.
Instalando pacotes úteis do Python
Você pode usar Keras, que é uma API de redes neurais de alto nível, escrita em Python e capaz de ser executada em TensorFlow, CNTK ou Theno. É compatível com Python 2.7-3.6. Você pode aprender mais sobre isso emhttps://keras.io/.
Use os seguintes comandos para instalar o keras -
pip install keras
Em conda ambiente, você pode usar o seguinte comando -
conda install –c conda-forge keras
Construindo um regressor linear usando ANN
Nesta seção, você aprenderá a construir um regressor linear usando redes neurais artificiais. Você pode usarKerasRegressorPara alcançar isto. Neste exemplo, estamos usando o conjunto de dados de preços de casas em Boston com 13 numéricos para propriedades em Boston. O código Python para o mesmo é mostrado aqui -
Importe todos os pacotes necessários conforme mostrado -
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
Agora, carregue nosso conjunto de dados que é salvo no diretório local.
dataframe = pandas.read_csv("/Usrrs/admin/data.csv", delim_whitespace = True, header = None)
dataset = dataframe.values
Agora, divida os dados em variáveis de entrada e saída, ou seja, X e Y -
X = dataset[:,0:13]
Y = dataset[:,13]
Uma vez que usamos redes neurais de linha de base, defina o modelo -
def baseline_model():
Agora, crie o modelo da seguinte maneira -
model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13, kernel_initializer = 'normal',
activation = 'relu'))
model_regressor.add(Dense(1, kernel_initializer = 'normal'))
Em seguida, compile o modelo -
model_regressor.compile(loss='mean_squared_error', optimizer='adam')
return model_regressor
Agora, fixe a semente aleatória para reprodutibilidade da seguinte forma -
seed = 7
numpy.random.seed(seed)
O objeto wrapper Keras para uso em scikit-learn como um estimador de regressão é chamado KerasRegressor. Nesta seção, iremos avaliar este modelo com um conjunto de dados padronizado.
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()))
A saída do código mostrado acima seria a estimativa do desempenho do modelo no problema de dados não vistos. Será o erro quadrático médio, incluindo a média e o desvio padrão em todas as 10 dobras da avaliação de validação cruzada.
Classificador de imagens: um aplicativo de aprendizado profundo
Redes Neurais Convolucionais (CNNs) resolvem um problema de classificação de imagens, ou seja, a qual classe a imagem de entrada pertence. Você pode usar a biblioteca de aprendizado profundo Keras. Observe que estamos usando o conjunto de dados de treinamento e teste de imagens de cães e gatos do seguinte linkhttps://www.kaggle.com/c/dogs-vs-cats/data.
Importe as bibliotecas e pacotes keras importantes como mostrado -
O seguinte pacote denominado sequencial inicializará as redes neurais como rede sequencial.
from keras.models import Sequential
O seguinte pacote chamado Conv2D é usado para realizar a operação de convolução, a primeira etapa da CNN.
from keras.layers import Conv2D
O seguinte pacote chamado MaxPoling2D é usado para realizar a operação de agrupamento, a segunda etapa do CNN.
from keras.layers import MaxPooling2D
O seguinte pacote chamado Flatten é o processo de conversão de todas as matrizes 2D resultantes em um único vetor linear longo e contínuo.
from keras.layers import Flatten
O seguinte pacote chamado Dense é usado para realizar a conexão completa da rede neural, a quarta etapa da CNN.
from keras.layers import Dense
Agora, crie um objeto da classe sequencial.
S_classifier = Sequential()
Agora, a próxima etapa é codificar a parte da convolução.
S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))
Aqui relu é a função do retificador.
Agora, a próxima etapa da CNN é a operação de agrupamento nos mapas de recursos resultantes após a parte da convolução.
S-classifier.add(MaxPooling2D(pool_size = (2, 2)))
Agora, converta todas as imagens agrupadas em um vetor contínuo usando lisonjeiro -
S_classifier.add(Flatten())
Em seguida, crie uma camada totalmente conectada.
S_classifier.add(Dense(units = 128, activation = 'relu'))
Aqui, 128 é o número de unidades ocultas. É uma prática comum definir o número de unidades ocultas como a potência de 2.
Agora, inicialize a camada de saída da seguinte maneira -
S_classifier.add(Dense(units = 1, activation = 'sigmoid'))
Agora, compile a CNN, nós construímos -
S_classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
Aqui, o parâmetro do otimizador é para escolher o algoritmo de descida gradiente estocástico, o parâmetro de perda é para escolher a função de perda e o parâmetro de métrica é para escolher a métrica de desempenho.
Agora, execute aumentos de imagem e, em seguida, ajuste as imagens às redes neurais -
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')
Agora, ajuste os dados ao modelo que criamos -
classifier.fit_generator(training_set,steps_per_epoch = 8000,epochs =
25,validation_data = test_set,validation_steps = 2000)
Aqui, steps_per_epoch tem o número de imagens de treinamento.
Agora que o modelo foi treinado, podemos usá-lo para predição da seguinte forma -
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'