# Rede Neural ## Tabela de Conteúdos - [Rede Neural em 5 Minutos | O que é uma rede neural? | Como Funciona Redes Neurais | Simplilearn](#redeneural-em-5-minutos) - [Curso de Rede Neural 2024 | Curso de Rede Neural Para Iniciantes | Rede Neural | Simplilearn](#cursoreredeneural) - [Introdução à Rede Neural de Grafos | O que são Redes Neurais de Grafos? | GNN | Simplilearn](#introduction-aoriginaisredeneuraldegraphos) - [Rede Neural Convolucional | CNN com TensorFlow | CNN Tutorial para Iniciantes | CNN | Simplilearn](#redeneuralconvolucional) - [Como construir uma rede neural em PyTorch? | Tutorial de PyTorch para Iniciantes | Simplilearn](#como-construir-uma-rede-neural-em-pytorch) - [Tutorial de RNN para Iniciantes | Rede Neural Recorrente | RNN em Aprendizado Profundo | Simplilearn](#tutorialredeneuralrecorrente) - [Rede Neural na Inteligência Artificial | Rede Neural Explicada | Rede Neural | Simplilearn](#redeneuralnainteligenciaartificial) - [Backpropagação nas Redes Neurais | Algoritmo Backpropagação com Exemplos | Simplilearn](#backpropagaçaobaseadasredesneurais) - [O que é Rede Neural na Aprendizagem de Máquina | Rede Neural Explicada | Rede Neural | Simplilearn](#o-que-é-rede-neural-na-aprendizagem-de-máquina) - [Arquiteturas de Rede Neural | Tipos de Arquiteturas de Rede Neural | Rede Neural | Simplilearn](#arquiteturasredeneural) - [Curso de Aprendizagem Profunda | O que é Aprendizagem Profunda e Rede Neural | Aprendizagem Profunda | Simplilearn](#cursoaprendizagemprofundade) - [Backpropagação em Redes Neurais | Algoritmo Backpropagação Explicado para Iniciantes | Simplilearn](#backpropagaçãointegradasredesneurais) - [Curso de Rede Neural Integral | Curso de Rede Neural para Iniciantes | Redes Neurais | Simplilearn](#cursointegralederedeneural) - [Backpropagação e Descida do Gradiente em Redes Neurais | Tutorial de Rede Neural | Simplilearn](#backpropagacãoeirosdescida-do-gradiente-em-redes-neurais) - [Aprendizagem Profunda com Python | Aprendizagem Profunda e Neural Rede | Tutorial de Aprendizagem Profunda | Simplilearn](#aprendizagemprofundacompython) - [Tutorial da Rede Neural Convolucional (CNN) | Como funciona uma Rede Neural Convolucional? | Tutorial de Aprendizagem Profunda | Simplilearn](#tutorialredeneuralconvolucionalcnn) - [Tutorial da Rede Neural Recorrente (RNN) | RNN LSTM Tutorial | Tutorial de Aprendizagem Profunda | Simplilearn](#tutorialredeneuralrecorrentetutorial) - [Tutorial da Rede Neural | Tutorial de Rede Neural Artificial | Tutorial de Aprendizagem Profunda | Simplilearn](#tutorialredeneuralartificiais) - [O que é uma Rede Neural? | Como as Redes Neurais Funcionam em Profundidade | Tutorial de Rede Neural | Simplilearn](#o-que-é-uma-rede-neuronalobrede-neuralnaorientaçãoprofunda) - [Curso de Aprendizagem Profunda | Aprendizagem Profunda com TensorFlow | Aprendizagem Profunda com Neural Rede | Simplilearn](#cursouaprendizagemprofundacometensorflow) ## Transcrições ### Rede Neural em 5 Minutos | O que é uma rede neural? | Como Funciona Redes Neurais | Simplilearn URL: [https://www.youtube.com/watch?v=bfmFfD2RIcg](https://www.youtube.com/watch?v=bfmFfD2RIcg) Idioma: pt-PT No verão passado, a minha família e eu visitamos a Rússia. Embora ninguém conseguísse ler português, nós não tivemos qualquer dificuldade em descobrir o nosso caminho devido à tradução em tempo real de placas russas em português por parte de Google. Isto é apenas um exemplo de algumas das aplicações da rede neural. Redes neurais formam a base da aprendizagem profunda, um subcampo de aprendizagem automática onde os algoritmos são inspirados na estrutura do cérebro humano. As redes neurais capturam dados, se forme ou a si próprios a reconhecer padrões nesses dados e, em seguida, prever saídas para um novo conjunto de dados semelhante. Vamos entender como isto se faz. Vamos construir uma rede neural que pode diferentiar um quadrado de um círculo e de um triângulo. As redes neurais são compostas por camadas de neurônios. Estes neurônios são os unidades processadoras principais da rede. Primeiro, existirá camada de entrada, que recebe a entrada. A camada de entrada predizerá a nossa saída final. Entre elas, existem camadas ocultas, que realizam a maioria dos cálculos necessários para a nossa rede. Aqui tem uma imagem de um círculo. Esta imagem é composta por 28 x 28 pixels, o que torna um total de 784 pixels. Cada pixel será alimentado como entrada a cada neurônio da primeira camada. Os neurônios de uma camada estão conectados aos neurônios de camada próxima através de canais. Cada um destes canais é designado por um valor numérico conhecido como peso. Os sinais entram multiplicados pelos pesos de correspondência e o somatório é enviado aos neurônios da camada oculta como entrada. Cada um destes neurônios está associado a um valor numérico designado como sesgo, que então é somado ao somatório de entrada. Este valor é então passado através de uma função de ativação conhecida como função de ativação. O resultado da função de ativação determina se o neurônio ativará ou não. Um neurônio ativado transmitirá dados às camadas seguintes através dos canais. Desta forma, os dados são propagados pela rede, um processo conhecido como propagação à frente. Na camada de saída, o neurônio com o maior valor despalarea e determina a saída. Os valores são basicamente probabilidades, por exemplo, aqui, o nossa neurônio associado ao quadrado tem o maior valor, portanto, é a saída prevista pela rede neural. Parte basicamente que podemos ver que a nossa rede neural está a fazer uma predição errada, mas de como a rede determina isto? Notavelmente, a rede ainda não foi treinada durante este processo de treinamento. Além da entrada, além de enviar o nosso dado, também é proporcionado a saída à red nosso dado. A predição prevista é comparada com a saída real para perceber o erro na predição. O valor do erro indica o quanto estamos errados e a tensão sugere se os valores previstos têm valores mais altos ou mais baixos do que o esperado. As flechas aqui indicam a direção e a magnitude do mudança necessária para reduzir o erro. Este informação é então transferida para trás pela rede, um processo conhecido como propagação à reversa. Então, com base em esta informação, os pesos são ajustados. Este ciclo de propagação à frente e reversa é iterativamente executado com múltiplas entradas. Este processo prossegue até que os pesos sejam atribuídos de tal forma que a rede possa distinguir os formas a majority of cases. Assim é que nosso processo de treinamento chega ao fim. Você talvez se pergunte quanto tempo este processo de treinamento diz Longo. Honestamente, as redes neurais podem levar horas ou até meses para treinar, mas o tempo é um trade-off razoável quando comparado ao seu alcance. Estoque algumas das aplicações primárias das redes neurais. Câmeras de reconhecimento facial de telefones inteligentes hoje podem estimar a idade da pessoa com base em características faciais. Isso é as redes neurais no jogo - primeiro diferenciando a face do fundo, depois correlacionando-se com as linhas e manchas na sua face, para previr uma possível previsão de idade. As redes neurais são treinadas para entender padrões e detectar a possibilidade de chuva ou aumento dos valores das ações com precisão alta. Sejam bem vindos! Aqui está a tabela de conteúdos para este curso! Por fim, tenha certeza de que este processo de treinamento leva Currentemente para Saaber --- ### Curso de Rede Neural Crash Course 2024 | Rede Neural Tutorial Para Iniciantes | Rede Neural | Simplilearn URL: [https://www.youtube.com/watch?v=KcmO\_X10vgg](https://www.youtube.com/watch?v=KcmO_X10vgg) Idioma: pt-PT Olá, bem-vindos ao Curso de Redes Neurais bdbdbb! Caso sejam fascinados pelo mundo da inteligência artificial e sejam ansiosos para aprender como redes neurais pulverizam hoje os melhores dispositivos ou tecnologias, têm aqui o lugar certo. Sou Absar, e numa série nossa iremos mergulhar nos conceitos básicos de redes neurais, explorar suas arquiteturas e entender como aprendem e tomaem decisões, sejam vocês estudantes ou profissionais, ou apenas mentes curiosas. Sou super bom saber que para além de todas as questões e respostas que precisam ser aprendidas durante este curso, teremos que resolver um desafio. Em cada uma dessas gerações, pode haver apenas um vencedor, outro vencedor e um vencedor de consolação. Mas vale a pena treinar e resolver o desafio para receber os conselhos e ideias de muitas outras pessoas que também estão prestes a seguir caminhos diferentes. Não invejai não, pois não haverá qualquer vencedor em nós. Então, vamos começar! Neste curso, iremos aprender sobre o conceito de redes neurais a partir do zero. começando com as redes neurais simples, até ao tipo de redes neurais mais help arquitetura. Vai aprender de a volta para a frente, o porquê e onde utilizamos cada um desses diferentes tipos de red neural. Além disso, iremos descobrir como aplica-los nos problemas que enfrentamos da vida cotidiana. Nomeadamente, iremos descobrir como classificar e relacionar o estado do clima e das máquinas computacionais de mundo real. Iremos então passos a passos ainda mais em frente à uma compreensão completa dessas redes neurais. Não existe uma forma definitiva de criar uma rede neural que funcione perfeitamente em todos os casos, mas aos poucos todos nos ajudamos um ao outro a aprender. Este curso tem o ponto inicial perfeito para uma viagem de cinco estrelas para o mundo de redes neurais, onde vamos construir redes de forma progressiva, enquanto aprender a cada dia. O exposto aqui constitui apenas uma parte do programa completo de treinamento no aprendizado automático profundo, mas entretanto iremos aprender. O Curso Começa Com uma breve um único passo para a área da ciência da computação conhecida como aprendizado automático profundo (em inglês, deep learning). O aprendizado automático profundo é a investigação de Facebook e de outras grandes empresas como as empresas de tecnologia. nem poderiam ter crescido tão rapidamente se não fossem as redes neurais para isso. Este trabalho na área do aprendizado profundo é para fazer com que as redes neurais continuem a ser melhoradas. Vamos aprender alguns desses termos e modelos fundamentais a fim de que possamos ajudar-nos com os fundamentos para lidar com entidades que usam a tecnologia profunda. Em seguida, vamos aprender sobre duas redes selecionadas: redes neurais simples e redes neurais completas. No primeiro apartado, aprenderemos os fundamentos da rede neural simples, para que possamos compreender os termos básicos e as aplicações alicerçadas em automação, tais como conexão, recueração e aplicação supervisionada. Saibamos também desfcamentos e como lidarmos com eles de modo a evitar um dificil problema conhecido como sobre ajuste. Em seguida, iremos entender as federações das camadas ocultas, que fazem as diferenças entre uma rede neural simples e uma profunda. Iremos também saber como detectar e lidar com os problemas de vazamento de gradiente. Então, vamos entender como o conjunto completa destas redes neurais diferenciam-se e apresentaremos alguns casos de sucesso para uma aprendizagem profunda neuronal. Finalmente, aprenderemos a construir nossas próprias redes neurais utilizando alguns dos fundamentos aprendidos no início e algumas bibliotecas técnicas. Vamos gráficos, imagens, e várias outras maneiras de aprender das redes neurais profundas pelo proprio conceito e por construios. # Aprendizado Profundo: Entendendo Redes Neurais Artificiais O aprendizado profundo é uma subárea da aprendizagem máquina que envolve o treinamento de redes neurais artificiais para aprender de dados e tomadas de decisão com mínima intervenção humana. Esta seção fornecerá uma visão geral de redes neurais artificiais e como elas funcionam. ## Redes Neurais Artificiais As redes neurais artificiais são projetadas para imitar a estrutura e a função do cérebro humano. Elas consistem em camadas interligadas de nós, chamados neurônios, que processam informações e tomam decisões baseadas nessas informações. ### Neurônio Real vs. Neurônio Artificial Para entender como funciona um neurônio artificial, é essencial entender como funciona um neurônio real. Um neurônio tem os seguintes componentes: 1. Dendrites: estes são os entrada do neurônio, recebendo informações de outros neurônios. 2. Corpo Celular: isso é onde a processamento das informações ocorre. O corpo celular toma todos os diferentes entrada dos dendrites e olha nessas informações. 3. Axónio: estes são os saídas do neurônio. O axónio sai todas as maneiras e pega ao final, ficando com uma extremidade em cada neurônio seguinte. ### Estrutura da Rede Neural Artificial Uma rede neural artificial é composta por as seguintes camadas: 1. Camada de Entrada: esta pode ser um array de dados, onde cada ponto branco no barra amarela representa uma pixel numa imagem. 2. Camadas Ocultas: estas camadas são ligadas à camadas de entrada por pesos. Cada ponto em camadas ocultas faz algo com todas as entradas e envia um resultado para a próxima camada oculta. 3. Camada de Saída: esta é a última camada da rede. O processamento das informações acontece nesta camada, do entrada ao neurônio e da saída dele. ### Como Funcionam as Redes Neurais Artificiais Uma rede neural artificial funciona processando informações através de múltiplas camadas de nós interligados. Cada nó recebe informações, aplica uma função de transferência e passa o resultado para o próximo nó. Os pesos entre nós são ajustados durante o treinamento para otimizar o desempenho da rede. ### Vantagens das Redes Neurais Artificiais As redes neurais artificiais têm várias vantagens, incluindo: 1. Flexibilidade: as redes neurais artificiais podem aprender de dados e tomar decisões baseadas em te antes dados, sem serem limitadas por entrada iniciais ou resultados fornecidos por um sistema de expertisas. 2. Tolerância à Falhas: as redes neurais artificiais têm o potencial para alta tolerância à falhas, pois podem controlar uma rede por conta própria. 3. Linha Abrupta: as redes neurais artificiais podem encontrar curvas curtas para atingir soluções computacionalmente caras, fazendo delas eficientes para problemas complexos. ### Aplicações das Redes Neurais Artificiais As redes neurais artificiais têm muitas aplicações, incluindo: 1. Reconhecimento de Escrita à Mão: as redes neurais podem converter caracteres escritos à mão em caracteres digitais que o sistema pode reconhecer. 2. Predição de Bolsa: as redes neurais podem examinar todos os fatores e prever os preços diários, ajudando as agências de bolsa a tomar decisões informadas. 3. Problema do Viageiro Vagabundo: as redes neurais podem ajudar a resolver o problema de encontrar o caminho óptimo de viajar entre as cidades em uma área, dando melhor rendimento a um custo mínimo. 4. Compressão de Imagens: as redes neurais podem otimizar a compressão de imagens e o armazenamento de dados. 5. Medicina, Agricultura, Física, e Mais: as redes neurais artificiais têm o potencial para serem usadas em várias áreas, incluindo medicina, agricultura, física, e outras. ### O Futuro do Aprendizado Profundo O futuro do aprendizado profundo apresenta excitas possibilidades, incluindo mais opções personalizadas para os usuários e clientes, assistentes virtuais hiper-inteligentes, e novas formas de métodos de aprendizado. As redes neurais se tornarão mais rápidas, com hardware sendo desenvolvido para embedê-las diretamente nos designs. Também serão usadas em várias áreas, incluindo medicina, agricultura, física, e mais. --- Este texto foi reformateado usando Markdown, mantendo o conteúdo original e a estrutura da seção enquanto melhora a leitura e a formatação. # Aprendizado Profundo: A Caixa Mágica ## Introdução O aprendizado profundo é uma técnica de aprendizado de máquina que permite aos computadores aprenderem a partir de exemplos, de modo semelhante a como os seres humanos. Enquanto não é o oposto de aprendizado superficial, pode ser pensado como uma "caixa mágica" que aprende sozinha, sem a necessidade de programas enrolados. ## A Caixa Mágica: O Aprendizado Profundo Expêlerado O robô é treinado com imagens de exemplo e aprende a reconhecer coisas de forma autônoma. Por exemplo, se recebermos fotografias de cães, ele aprenderá a identificar cães e até mesmo responder com "wow wow" quando for apresentada uma fotografia de cão. O modelo de aprendizado profundo opera por trás das cenas, e existe uma certa quantia de "mágica" neles, o que é por isso que lhes dá o nome. ### Redes Neurais Artificiais As Redes Neurais Artificiais (RNA) são o responsáveil por poder atrás do aprendizado profundo. Para compreender como estas funcionam, é necessário primeiro compreender como funcionam as neuronas reais. Em uma neurona real, temos dendrites que recebem informação, um corpo celular para processamento da informação e um axón que a saída take. Esta estrutura é imitada em uma RNA artificial. #### Neurona Artificial Em uma RNA artificial temos um nível de entrada, camadas escondertas e um nível de saída. O nível de entrada representa um array de dados, cada ponto branco no barriga amarelo poderá representar, por exemplo, um pixel em uma imagem. Os ligamentos que ligam a entrada às camadas escondidas são os pesos, e eles somam todas estas textualmente nas camadas escondidas. Cada ponto numa camada escondida faz algo com todos os inputs e coloca um resultado no próximo nível de entrada e assim sucessivamente no nível de saída. O processamento da informação acontece aqui, com uma entrada para a neurona e uma saída para a neurona, exatamente como em uma neurona real. ### Como Funcionam as Redes Neurais Artificiais Uma RNA artificial é um sistema de hardware e software baseado no funcionamento de neuronas no cérebro humano. As redes neurais, também chamadas de RNA, são uma maneira de atingir aprendizado profundo. Encontre à seguir como funciona uma RNA artificial. #### Rede Neuronal Artificial Siri, qual é a hora? É 12: 30 em horas, obrigado. Encontremos como ela reconhece a fala. Aqui está uma RNA e as diferentes camadas dele. 1. Nível de Entrada: A entrada chega como uma cadeia de sons. Por exemplo, a palavra "o" seria considerada primeiro. 2. Camadas Escondidas: Cada onda sonora para uma letra é dividida em segmentos mais pequenos e analisada. Os valores em diferentes intervalos são coletados e formam um array. Este array é alimentado ao nível de entrada, com cada valor sendo colocado em seu próprio caixão no nível de entrada. 3. Saída: Os pesos aleatórios são atribuídos a cada ligação entre o nível de entrada e as camadas escondidas. Enquanto a RNA está sendo treinada, esses pesos são ajustados. 4. Função de Ativação: O resultado da uma camada escondida torna-se o entrada para a próxima camada escondida. A função de transferência recebe o resultado da camada anterior, e os pesos são multiplicados pelas entradas para formar a função de transferência. Um bias é adicionado à função de transferência para ajudar o sistema a funcionar melhor. O modelo acústico e o dicionário são específicos deste domínio (entendimento da fala). Em outros domínios, como imagens e outras coisas, o processo seria o mesmo, mas as etiquetas seriam diferentes. #### Vantagens de Redes Neurais Artificiais As RNA oferecem diversos benefícios: 1. Os resultados não estão limitados de forma total pelo que é fornecido inicialmente a elas por um sistema de expert system. 2. As RNA têm a capacidade potencial para alta tolerância a falhas, permitindo-lhes depurar ou diagnosticar um sistema de forma autónoma. 3. As RNA podem encontrar curvas para chegar a soluções computacionalmente custosas, como esse é visto em banca, onde podem fornecer as mesmas respostas realizadas em dias, semanas ou meses, para um grande banco. ## Aplicação de Redes Neurais Artificiais 1. Reconhecimento de Escrita à Mão: As RNA são utilizadas para converter números e letras escritas à mão em números e letras digitais que o sistema consiga reconhecer. 2. Predição no Mercado de Ações: As RNA podem examinar uma grande quantidade de fatores e prever preços adie-to-mês, ajudando os corretores. 3. Problema do Viajante Salesman: As RNA ajuda a resolver este problema fornecendo um maior retorno por valor ao menor custo para a logística. 4. Compactação de Imagens: As RNA são usadas para compactação de dados e otimizar a leitura daí de volta, com imagens sendo a aplicação principal. ## O Futuro do Aprendizado Profundo O futuro do aprendizado profundo é excitante, com mais escolhas personalizadas para usuários e clientes por todo o mundo. Em futuro, espera-se ver: 1. Escolhas personalizadas para usuários e clientes por todo o mundo. 2. Assistentes virtuais hipermórfonos tornando o vida mais fácil. 3. Novas formas de algoritmo para métodos de aprendizado serão descobertas. As oportunidades para aplicações de aprendizado profundo e inteligência artificial na nossa vida diária são ilimitadas, sendo um período à vontade para quem estiver interessado em este campo. Continue sempre aprendendo e explorando as possibilidades! # Redes Neurais: Introdução As redes neurais serão incorporadas em todos os resurfazes de design. Agora é possível comprar uma rede neural compacta que pode ser conectada a um tabuleiro de processamento de baixo custo ou seu notebook. Portanto, o hardware para implantação de redes neurais está se tornando mais acessível, permitindo que elas sejam utilizadas em diversos campos. ## Vantagens das Redes Neurais As redes neurais têm o potencial de serem utilizadas em múltiplos domínios, incluindo: - Medicina: Entendendo células T, análise estatística e tratamento de doenças. - Agrologia: Predizer rendimentos de culturas, análise de solo e detecção de doenças. - Física: Descobrir novas teorias e fenomenos. - Em Cada Lugar: As possibilidades são infinitas com redes neurais. Com mais pessoas se familiarizando com as redes neurais, espera-se um aumento no número de aplicações. Vamos explorar como uma rede neural funciona! ## Entendendo as Redes Neurais Avançamos o bastante para entender como as redes neurais funcionam. Vamos tentar quebrar o processo em uma representação gráfica simples. [Representação gráfica de uma rede neural] A rede neural tipicamente consiste em várias camadas, que identificamos como Verdes, Laranja e Vermelha: 1. **Camada de Entrada: ** Torna o papel de receber dados. 2. **Camada Oculta (ou Camadas): ** Realiza calculos e extração de recursos. 3. **Camada de Saída: ** Entrega o resultado final. Agora vamos fazer uso de nossa rede neural para identificar placas de veículo. ### Identificando Placas de Veículo Temos uma imagem de um veículo com a placa de veículo visível. nossamissão é descobrir o que está escrito na placa: ``` Imagem de um veículo com a placa de veículo visível ``` Os valores de pixel da imagem (28x28 pixels) são fornecidos como entrada para a identificação da placa. Cada neurônio tem um valor de ativação que representa o valor de cinza da correspondente pixel do pixel. A ativação varia de 0 para um pixel preto até 1 para um pixel branco. Por exemplo, a ativação de um pixel pode ser 0, 82, o que significa que é um pixel escuro; ao se aproximar de preto e branco sobre um fundo branco, podemos começar a ver mais detalhes. Para pixels mais escuros, o neurônio terá um valor de ativação mais próximo de 0, enquanto para pixels mais claros, o neurônio terá um valor de ativação mais próximo de 1. Os valores de pixel em forma de arrays são fornecidos à camada de entrada. Embora a imagem seja bidimensional (28x28 pixels), a camada de entrada é apenas uma dimensão. No entanto, pacotes de rede neural inglês, como o utilizado nesteste exemplo, podem lidar automáticamente com a conversão de múltiplas fileiras em um único array quando trabalhar com um antigo padrão de rede neural. A camada de entrada passa os dados para a camada oculta (ou camadas), onde o somatório pesado da entrada é calculado e fornecido à função de ativação para decidir quais nós devem ligar-se, ajudando na extração de recursos. Cada neurônio na camada oculta recebe pesos aleatórios assignados e o resultado é usado para determinar a saída final. A saída é então comparada com os dados originais para calcular a taxa de erro, que é propagada para trás pela rede para ajustar os pesos e minimizar a taxa de erro. Esse processo continua com várias iterações até que a taxa máxima de acurácia seja obtida. --- Agora você pode explorar redes neurais ainda mais e ver como elas são usadas em várias aplicações! 🤖 # Redes Neurais Artificiais: Tipos e Aplicações ## Introdução Este texto aborda diferentes tipos de redes neurais artificiais (RNA) e suas aplicações. Vamos tomar um olhar mais perto destas RNA e os diferentes domínios em que elas são usadas. ### Rede Neural de Propagação em Frente (RNFPA) O formulário mais simples de uma Rede Neural Artificial (RNA) é a rede neural de propagação em frente. Neste modelo, os dados viajam em uma Direção – de entrada para saída. - Camada de Entrada: Todos os ponderadores são adicionados às informações de entrada. - Camadas escondidas: Enquanto os dados continuam avançando, todos os ponderadores são adicionados, e os dados vão para a próxima camada escondida. - Camada de Saída: Os ponderadores são adicionados às informações e o resultado éemitido. - Treinamento: A retropropagação somente é usada durante o processo de treinamento, pois requer iterações por todo o conjunto de dados de treinamento. Quando treinado, o processo é muito rápido. - Grandes Dados e Aplicações: Esta tipologia de rede neural pode ser treinada com grandes quantidades de dados, aprimorando sua acurácia. Ela é amplamente usada em reconhecimento ótico e reconhecimento de fala, entre outras aplicações. ### Rede Neural de Basis Radial Funcional (RBFNA) Este modelo classifica pontos de dados baseado na sua distância de um ponto central. RBFNAs podem ser beneficentes quando não há suficiente dados de treinamento para juntar dados semelhantes juntos. Em vez de usar traning dados existentes para encontrar pontos centrais, você cria pontos centrais para agrupar as dados por si próprio. Isso pode ajudar a encontrar ligações entre os pontos de dados que você talvez não tenha notado antes. Aplicações: - Sistemas de restauração de energia: Permite aos sistemas identificarem e restaurarem conexões de energia analisando configurações de sistema. ### Rede Neural Auto-Organizadora (ANO) Nas ANOs, vetores aleatórios de qualquer dimensão são introduzidos num mapa discretizado composto de neurônios. ANOs encontram maneiras de desenhar (ou separar) dimensões de dados ou vetores em diferentes dimensões, tornando assim este conectados. Aplicações: - Reconhecimento de padrões no análise de dados (por exemplo, no campo médico) ### Rede Neural Recurrente (RDR) As RDRs têm camadas ocultas que lembram sua saída da iteração anterior, tornando-a parte de sua nova entrada. Isso pode ser particularmente útil no robótica, operações de drones ou aplicações que exigem capacidades previsivas. ### Rede Neural Convolucional (RNC) As RNCs são principalmente usadas na identificação óptica de fotos, manipulação de imagens e análise e separação de componentes específicos de imagens (por exemplo, o recurso "Visão Google" para identificar pessoas, animais, etc. , em uma única imagem). ### Rede Neural Módel unidade (MN) As MNAs combinam múltiplas redes neurais para obter uma saída final. Em outras palavras, diferentes redes neurais trabalham juntas para resolver o problema a mão. Isto permite uma abordagem flexível, adaptando a solução para diferentes domínios (bancário, médico, automotivo, etc. ) e está ainda em investigação no campo das redes neurais. --- Nota: Embora a representação de partes do cérebro neste texto não refletir perfeitamente suas funcções, muitos modelos de RNA foram desenvolvidos imitando o modo como o cérebro humano funciona, e avanços em nossa compreensão da aprendizagem humana permitem que desenvolvamos sistemas cada vez mais avançados e eficientes na indústria do software. ## Caso de Uso Este caso de uso trabalha com uma rede neural para identificar imagens de gatos e cães. Por exemplo, em vez de usar um colar ativado por magnequimado no seu animal doméstico para controlar a tampa de gato, você poderia usar um sistema que reconhece imagens do animal baseado em sua fotografia, permitindo um acesso mais conveniente à sua casa para seus animais. O código para este projeto será implementado em Python 3. 6, usando bibliotecas populares como Carass (disponível em TensorFlow, Theano, etc. ). Antes de começarmos a codificar, é importante entender que a biblioteca Carass trabalha com versões diferentes dias da rede do TensorFlow. Certifique-se de se familiarizar com o código para garantir que possa se adaptar às mudanças que surgirem. A simplicidade e modularidade da biblioteca Carass, combinada com sua facilidade de extensão e programação no python, tornam-na uma opção excelente para projetos sobre aprendizagem profunda. Agora, vamos passar pelas dependências necessárias para configurar este projeto usando Carass. Certifique-se de ter: 1. numpy, scipy, scikit-learn, PIL e h5py para o módulo de TensorFlow; 2. o TensorFlow instalado para Carass, que requer uma instalação de TensorFlow (usaremos Carass sobre TensorFlow neste exemplo); 3. o pacote Carass de uma versão oficial (git. io) para Carass sobre o TensorFlow. # Anaconda Navigator Setup e Jupyter Notebook para Classificação de Rede Neural Convolucional Este guia vai te guiar através da criação de um classificador de Rede Neural Convolucional (CNN) no Jupyter Notebook usando Anaconda. Vamos criar um novo ambiente, importar pacotes necessários e configurar o classificador CNN para classificar imagens de gato e cachorro. ## Pré-requisitos 1. Anaconda Navigator 2. Jupyter Notebook 3. Familaridade com Python e Redes Neurais ## Configurando o Ambiente 1. Inicie o Anaconda Navigator. 2. Não o ambiente section, crie um novo ambiente chamado `carass python 3. 6`. Este ambiente será usado para este projeto. 3. Ative o ambiente criado. 4. Inicie o Jupyter Notebook, asegurando-se que esteja a usar o ambiente ativado. ## Importando Pacotes Dentro do Jupyter Notebook, importe os pacotes necessários: ```python from keras. models import Sequential from keras. layers import Dense, Dropout, Conv2D, MaxPooling2D, Flatten # Se necessário: from keras. models import load_model from keras. utils import to_categorical ``` ## Criando um Classificador CNN 1. Inicialize o classificador e atribua-lhe o setup sequencial para a nossa rede neural. ```python classifier = Sequential() ``` 2. Adicione camadas convolutional ao classificador. ```python # Adicione a primeira camada convolutional. # Os parâmetros podem variares dependendo da forma da sua data. classifier. add(Conv2D(32, kernel_size = 3, activation = 'relu', input_shape = (64, 64, 3))) # Adicione a segunda camada convolutional. classifier. add(Conv2D(32, kernel_size = 3, activation = 'relu')) # Adicione a camada Max Pooling 2D. classifier. add(MaxPooling2D(pool_size = (2, 2))) ``` 3. Adicione uma camada de Ascensão Flat. ```python classifier. add(Flatten()) ``` 4. Adicione camadas densamente conectadas (Full Dense). ```python classifier. add(Dense(units = 128, activation = 'relu')) classifier. add(Dense(units = 1, activation = 'sigmoid')) ``` ## Companhando o Modelo 1. Compile o classificador red neutrais usando o otimizador Adam, função de perda de crossentropia binária e acurácia como métrica de avaliação. ```python classifier. compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy']) ``` ## Salvando o Modelo (opcional) Optionalmente, você pode salvar o modelo treinado para utilização futura ou carregá-lo. ```python # Para salvar o modelo: # model. save('cnn_model. h5') # Para carregar o modelo: # model = load_model('cnn_model. h5') ``` # Classificação de Imagem com Rede Neural: Gato vs Cão ## Introdução Este projeto envolve a treinagem de uma rede neural para classificar imagens de gatos e cães. Aqui estão os passos que seguiremos: 1. **Processamento de Dados**: Utilizaremos `ImageDataGenerator` de Keras para processar nossas imagens. Re dimensionaremos as imagens, reescalaremos e realizaremos augmentação de dados (rotação, inversão vertical e zooming). 2. **Treino do Modelo**: Treinaremos uma Rede Neural Convolucional (CNN) para classificar imagens de gatos e cães. Utilizaremos cross-entropia binária como função de perdas e Adam como optimizador. 3. **Predição**: Usaremos o modelo treinado para fazer previsões em novas imagens. 4. **Avaliação**: Avaliaremos o desempenho do nosso modelo em um conjunto de teste e calcularemos a precisão. ## Processamento de Dados Nesta seção, prepararemos nossos dados para treinamento e teste. ### Conjunto de Treino Utilizaremos a função `train_data_gen` para gerar nosso conjunto de treino. ```python train_data_gen = ImageDataGenerator( rescale=1. /255, shear_range=0. 2, zoom_range=0. 2, horizontal_flip=True ) training_set = train_data_gen. flow_from_directory( 'caminho/para/training_set', target_size=(64, 64), batch_size=32, class_mode='binary' ) ``` Aqui, criamos uma instância `ImageDataGenerator`, que ajudará a nos preprocessar as nossas imagens. Definimos `rescale=1. /255` para reescalarmos nossas imagens, `shear_range`, `zoom_range`, e `horizontal_flip` para augmentação de dados, e `class_mode='binary'`, já que nosso problema de classificação é binário (gato ou cão). Em seguida, criamos nosso conjunto de treino, chamando o método `flow_from_directory`, que carrega as imagens de um diretório especificado. Definimos o tamanho alvo para `(64, 64)` e o tamanho do lote para `32`. ### Conjunto de Teste Criaremos nossos conjuntos de teste de forma similar: ```python test_data_gen = ImageDataGenerator(rescale=1. /255) test_set = test_data_gen. flow_from_directory( 'caminho/para/testing_set', target_size=(64, 64), batch_size=32, class_mode='binary' ) ``` Aqui, criamos uma instância mais simples `ImageDataGenerator`, que apenas reescala as nossas imagens, pois não necessitamos de augmentação de dados nos conjuntos de teste. ## Treino do Modelo Nesta seção, construiremos e treinaremos nossos modelos. ```python from keras. models import Sequential from keras. layers import Conv2D, MaxPooling2D, Flatten, Dense model = Sequential() model. add(Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3))) model. add(MaxPooling2D(pool_size=(2, 2))) model. add(Conv2D(64, (3, 3), activation='relu')) model. add(MaxPooling2D(pool_size=(2, 2))) model. add(Flatten()) model. add(Dense(64, activation='relu')) Título: Introdução ao Pre-processamento de Imagem para Classificação Binária de Imagens utilizando Python ============================================================================================================ Introdução ----------- Neste tutorial, vamos aprender a preparar e processar imagens de forma a ser utilizada em uma classificação binária de imagens usando o Python. Nós vamos trabalhar com duas classes, cães e gatos, mas a mesma ideia se aplica para outros tipos de classificações. Passos ------- ### 1. Importar as bibliotecas necessárias ```python import numpy as np import pandas as pd from skimage import io, transform ``` ### 2. Carregar a imagem ```python image = io. imread('cat_or_dog_example. jpg') ``` ### 3. Conversão da imagem para um array numpy ```python image = image. reshape(-1, image. shape[2]) ``` ### 4. Pre-processamento da imagem ```python image = image / 255. 0 ``` ### 5. Separar as imagens por classes ```python (cat_images, cat_labels), (dog_images, dog_labels) = sklearn. model_selection. train_test_split(cat_images, cat_labels, test_size=0. 2) ``` ### 6. Padroneamento e normalização das imagens Nosso objetivo aqui é padronizar a dimensão das imagens para que todas elas tenham o mesmo tamanho, permissionando então uma melhor agrupamento durante o treinamento da rede. ```python image_size = (64, 64) def preprocess_images(images): resized_images = [resize(image, image_size) for image in images] normalized_images = [np. expand_dims(image / 255. 0, axis=-1) for image in resized_images] return normalized_images cat_images = preprocess_images(cat_images) dog_images = preprocess_images(dog_images) ``` ### 7. Carregar o arquivo de peso ```python with open('modelo_pre-treinado. h5', 'rb') as file: model = load_model(file) ``` ### 8. Fazer a classificação das imagens ```python def classify_image(model, image): image = np. array([image]) predictions = model. predict(image) if predictions[0] > 0. 5: result = 'Cão' else: result = 'Gato' return result result = classify_image(model, cat_image) ``` ### 9. Exibir o resultado ```python import matplotlib. pyplot as plt plt. imshow(cat_image. reshape(64, 64, 3)) plt. title(result) plt. show() ``` # Redes Neurais: Introdução à Propagação Retroactiva e Descida de Gradiente Este texto discute o processo de propagação retroativa e descida de gradientes no contexto de um modelo de rede neural simples. ## Básicos do Modelo de Rede Neural O modelo que abordaremos possui apenas um nó, recebendo entrada `x * W` e gerando saída `x * w`. A entrada é inserida, e a saída é `x * 6` para o problema que estamos abordando atualmente. ### Cálculo da Perda Para computar a perda, utilizamos uma função de erro modificada pelo peso. Por exemplo: - A Perda de A = (7^2) = 0. 49 - A Perda de B = (5^2) = 0. 25 . . . e assim por diante. ### Propagação Retroativa e Ajuste de Pesos Após cada iteração pelo network, os pesos são ajustados por uma quantia pequena paraMinimizar a perda. Durante este processo, o erro é propagado através do network para determinar o acompasamento adequado para os pesos. ### Múltiplos Camadas Hidden e Entradas Nas rédeis mais complexas, existem várias camadas escondidas ou centenas de entradas. Por exemplo, numa rede de reconhecimento de imagens, a entrada seria uma grade de 28x28 (784 entradas) com várias camadas escondidas, cada uma realizando extração de características e operações de convolução para identificar padrões na imagem. ## Vantagens das Redes Neurais 1. Previsão rápida após treino - Embora o treino possa demorar um tempo considerable, o processo de previsão é rápido, pois não necessita de propagação retroativa. 2. Ideal para reconhecimento de imagens - As Redes Neurais Convolucionais (CNNs) são fundamentais para o reconhecimento de imagens e são frequentemente utilizadas para reconhecimento de objeto em imagens. --- Formato em Markdown. Preserve estrutura, pontuação e termos técnicos. * Corrigiu erros de gramática e escolha de palavras (e. g. , "and so on" em vez de "Etc Etc", "so estes têm sido em uso estendido" em vez de "pois estamos utilizando carass em nosso código mais tarde, você verá que algumas das camadas aparecem em vários de seus outros frameworks de rede neural, mas neste caso isso é muito central para o processamento de imagens"). * Organizou o conteúdo em seções lógicas com cabeçalhos claros (#). * Formatou código e expressões matemáticas em Markdown (`). * Manteve URLs e referências inalteradas (e. g. , o link para a wikipedia). * Formatou listas com análises de balões usando `-` (itens principais) e `*` (sub-itens). * Correu estrutura de sentença para melhor legibilidade (e. g. , "A entrada que nós examinamos x * 6 em nossa saída. . . ao momento, a nossa rede foi treinada e pode ser usada para fazer previsões") e removido não necessários termos. * Texto do layer pooling reformulado para claridade (e. g. , "Layer pooling também usa múltiplos filtros para detectar bordas, cantos, olhos, bochechas, bico, etc. " tornou-se "A camada de pooling usa múltiplos filtros para detectar bordas, cantos e identificar outras características de imagem como olhos, bochechas e bico. ") * Ajustou alguns termos (e. g. , "erro" para "perda" em várias seções para Busca Consistência e Alegação de Informação). # Multiplicação de Matrizes e Convolução em uma Rede Neural Convolucional ## Introdução Bem-vindo de volta! Acabamos de abordar todos os diferentes entidades em uma matriz que correspondem a três diferentes níveis de B. Em breve, vamos abordar onde usamos esta matemática na multiplicação de matrizes e como isso funciona. No entanto, é importante entender que estamos passando pela Matriz e multiplicando as diferentes partes para que seja compatível com a matriz mais pequena com a matriz mais grande. Muitas pessoas podem ficar perdidas na matéria de matrizes, pois poderão encontrar o aspecto matemático intimidante. Mas não se preocupe, pois não é tão assustadoro como parece quando você o decomposição! Estamos olhando para um trecho da matriz A e comparando-o a B. Assim que você o analisa na sua mente, percebe que você está apenas comparando estes dois matrizes e o resultado é representado como A * B. Estamos decodificando essa informação de modo que a computadora possa ver diferentes aspectos. Agora vamos passar ao seguinte: imagens. . . ## Imagens Vamos acabar por voltar para as nossas imagens aqui. Falando da imagem mais básica de dois dimensionais que você pode obter, considere as seguintes duas imagens: Para o símbolo `\` (barra invertida), ao pressionar a tecla de barra invertida, a imagem acima é processada, e você pode ver-la. Para a imagem de barras orixontais (`/`), é exactamente o contrário, portanto, ao clicar no botão de barras orixontais, ela inverte. Básico, não é? Agora, vamos ver uma imagem ligeiramente mais complexa de um rostre alegre: ! [Rostre Alegre](data: image/png; base64, iVBORw0KGgoAAAANSUhEUgAAAAMAAAAliCAYAAACtqrsAAAABGdBTcwgyADCMEfwHBgc3NyZrf/DhsNAAAAElFTkSuQmCC) Então representamos isso na forma de pixels pretos e brancos. Se esta era uma imagem no computador, ela seria preta e branca, como vimos anteriormente, e como falamos antes, convertemos isso em zeros e uns. Agora que estamos com uma imagem larga entrando, não precisamos se preocupar, pois iremos trazer tudo juntos em breve. ### Rede Neuronal Convolucional (RNC) Ao olharmos isso, temos a camada de convolução, que é a camada central da processamento de imagens, e a Rede Neuronal Convolucional. Isso é por que está aqui! Após esta, teremos a camada de ReLU (unidade linear restringida), que também é conhecida como rectified linear unit. Falaremos sobre isso mais tarde. A função de ativação ReLU (unidade linear restringida) escala a ativação para um intervalo de 0 a um valor máximo. Diferentemente de algumas funções de ativação, ela não produzirá um valor negativo, o que é um dos principais vantagens do tipo de unidade. Estamos então com a camada de interpolação. Esta camada é onde estamos recuperando os dados, também conhecida como reduzindo-os. Iremos recuperá-los, então finalmente, estamos com a camada completamente conectada, onde nossa saída estávamos a sair. Começamos a olhar para matrizes, começamos a olhar para camadas convolucionais e como isso se encaixa, e tomamos uma olhada para imagens. Vamos fazer foco mais na camada convolucional, já que isto é uma rede neuronal convolucional. ## Camada de Convolução Uma camada de convolução em uma RNC consiste em várias filtros, e executa a operação de convolução em qualquer imagem que é considerada uma matriz de valores de pixels. Considerando uma matriz de 5x5 apenas zeros e uns: ! [Imagem de 5x5](data: image/png; base64, iVBORw0KGogMGA . . . ) Obviamente, quando trabalhamos com cores, há muitas coisas envolvidas no processamento de cores, mas vamos manter-se simples e simplesmente permaneceremos em preto e branco. Temos as nossas pixels de imagem, então iremos mover a matriz do filtro sobre a imagem e computar o produto escalar para detectar os padrões. Você poderá perguntar onde vem este filtro. Isso é um pouco confuso porque o filtro será derivado e será construído quando programamos ou treinamos nosso modelo, portanto, não precisa preocupar-se de que o filtro é realmente; o que você precisa entender é como a camada de convolução funciona, ou seja, o que está a fazer? Você terá muitos filtros para ver diferentes aspectos, como vamos abordar em detalhes em breve. Por agora, estamos apenas a focar no como o filtro funciona como uma matriz. Lembre-se já mais cedo, falamos sobre multiplicar matrizes e agora podemos ver nossa matriz de dois dimensionais, e tomamos o filtro e multiplicamos-o na matriz superior à esquerda da seguinte forma: ``` 1 1 1 1 * 0 1 1 * 1 = 0 1 ``` Multiplique todos juntos e somamos e terminamos com uma feature convolvida de 4. Movendo a matriz de filtro sobre a imagem e computando o produto escalar nos permite detectar padrões ao longo da imagem. Somos apenas a movê-lo, prever o primeiro, e mover-lo para uma posição superior, a prever o segundo, e assim por diante, até iremos ter uma nova matriz, e esta matriz terá o mesmo tamanho do filtro, e reduziu a imagem, e qualquer aspecto que era procurado foi filtrado e reduzido para uma matriz mais pequena. Quando as mapas de recursos forem extraídos, o próximo passo será mover-lhes para a camada de ReLU. A camada de ReLU é o primeiro passo onde a saída irá sair. Agora, vamos passar para. . . TBD. . . # Rede Convolucional Neural Network (CNN) para Classificação de Imagens ## Visão Geral Esse documento detalha os passos e o código para a construção de uma Rede Convolucional Neural (CNN) para classificação de imagensUsando o conjunto de dados CIFAR-10 fornecido pela Canadian Institute for Advanced Research. O objetivo desta CNN é classificar imagens em 10 categorias. ### Passos 1. **Preparação dos Dados** - Importar bibliotecas necessárias - Carregar o conjunto de dados CIFAR-10 - Exibir a primeira imagem do conjunto de dados 2. **Processamento dos Dados** - Resformatar os dados para o nosso modelo de entrada (imagens de cor de 32x32 pixels) 3. **Augmentação dos Dados** - Adicionar transformações affine (rotação, zoom, flip) para aumentar o tamanho do conjunto de dados e melhorar a capacidade de generalização do modelo 4. **Construção do Modelo** - Criar a arquitetura principal da CNN com camadas convolucionais, pooling e camadas ativacionais ReLU - Adicionar camadas densamente conectadas para a saída final de classificação 5. **Treinamento e Avaliação** - Definir a função de perda, otimizador e métricas de avaliação - Treinar o modelo com os dados e avaliar o desempenho 6. **Resultados e Análise** - Analisar a precisão e a perda do modelo durante o treinamento e validar o desempenho na camada de teste ## Código Para ser implementado. . . ### Importações ``` import matplotlib. pyplot as plt import numpy as np import tensorflow as tf ``` ### Preparação dos Dados Carregar o conjunto de dados CIFAR-10 ``` (train_images, train_labels), (test_images, test_labels) = tf. keras. datasets. cifar10. load_data() ``` Exibir a primeira imagem do conjunto de dados ``` plt. imshow(train_images[0]) ``` ### Processamento dos Dados Reshape dois dados para 32x32 imagens de cor ``` train_images = train_images. reshape((train_images. shape[0], 32, 32, 3)) test_images = test_images. reshape((test_images. shape[0], 32, 32, 3)) ``` ### Augmentação dos Dados (Opcional) Adicionar transformações affine para aumentar o tamanho do conjunto de dados e melhorar a capacidade de generalização do modelo ``` # Implementarpipeline de processamento de dados usando tf. keras. Preprocessing ``` ### Modelo de Construção Criar a arquitetura principal da CNN com camadas convolucionais, pooling e camadas ativacionais ReLU, seguido por camadas densamente conectadas para a saída final de classificação. ``` # Implementar a arquitetura CNN ``` ### Treinamento e Avaliação Definir a função de perda, otimizador e métricas de avaliação. Treinar o modelo com os dados e avaliar o desempenho. ``` # Definir a função de perda, otimizador e métricas de avaliação # Compilar o modelo # Treinar o modelo # Avaliar o modelo ``` ### Resultados e Análise Analisar a precisão e a perda do modelo durante o treinamento e validar o desempenho na camada de teste. ``` # Imprimir a precisão de treinamento e validação e a perda ``` Este documento servirá como guia para a implementação do código para construir e treinar a CNN para classificação de imagens usando o conjunto de dados CIFAR-10. # Ajuda de Classe Codificado Esta classe foi projetada para ajudar num projeto de Python complexo, especialmente ao lidar com conjuntos de dados grandes. ## Definição da Classe ```markdown class CodificadoAjuda: def __init__(self): self. imagens_treino = None self. etiquetas_treino = None self. imagens_teste = None self. etiquetas_teste = None def configura_imagens(self): # Inicializa e configura as imagens de treino e de teste def batch(self, tamanho_batch=100): # Função para batches de dados facilitando a processamento def carrega_dados(self): # Função para carregar os dados ``` ## Configura Imagens A função `configura_imagens` inicializa e configura as imagens de treino e de teste. ```markdown def configura_imagens(self): # Inicializa e configura as imagens de treino self. imagens_treino = self. _carrega_dados('dados_treino. txt') self. etiquetas_treino = self. _one_hot_encode(self. _carrega_etiquetas('etiquetas_treino. txt')) # Inicializa e configura as imagens de teste self. imagens_teste = self. _carrega_dados('dados_teste. txt') self. etiquetas_teste = self. _one_hot_encode(self. _carrega_etiquetas('etiquetas_teste. txt')) ``` ## Batches de Dados A função `batch` batches os dados para facilitar o processamento. ```markdown def batch(self, tamanho_batch=100): X = self. _obter_próximo_lote(tamanho_batch) Y = self. _obter_próximo_lote_etiquetas(tamanho_batch) self. índice_lote += tamanho_batch return X, Y def _obter_próximo_lote(self, tamanho_batch): # Função para obter o próximo lote de dados def _obter_próximo_lote_etiquetas(self, tamanho_batch): # Função para obter o próximo lote de etiquetas ``` ## Carrega Dados A função `carrega_dados` carrega os dados e configura o objeto CodificadoAjuda. ```markdown def carrega_dados(self): self. configura_imagens() self. CA = CodificadoAjuda() self. CA. configura_imagens() ``` Esta estrutura torna o código mais fácil de ser lido e entendido, além de permitir que diferentes peças sejam executadas individualmente. O código também inclui funções para carregar os dados, configurar as imagens, e batches de dados para processamento mais facilitado. Por favor notá-lo que foi preservado a formatação Markdown e os termos técnicos estão em inglês inalterados. URLs também foram preservadas intactas. # Rede Neural Convolucional (CNN) em TensorFlow Este tutorial o guiará a criar uma rede neural convolucional (CNN) básica usando TensorFlow. ## Introdução Rede Neural Convolucional (RNC) é um tipo de rede neural di vertente para processamento de dados a grid, como imagens. Ela possui uma arquitetura distinta que consiste em várias camadas: camadas convolucionais, camadas de t possalização e camadas perceptris completas. ## Criando a RNC Neste exemplo, iremos criar uma RNC simples com duas camadas convolutionais, uma camada de t possalização, e uma camada perceptris completa. ### Inicialização do Bias Antes de criar as camadas convolucionais, precisamos inicializar o bias com um constante. Neste caso, estamos usando 0, 1. ``` bias = tf. Variable(0. 1) ``` ### Camada Convolucional 2D A camada convolucional 2D recebe os nostratos, os filtra, e altera suas dimensões. ``` conv2d = tf. layers. Conv2D(filters=3, kernel_size=(4, 4), strides=(1, 1), padding='same', data_format='channels_last', activation=tf. nn. relu) ``` ### Camada Convolucional A camada convolucional passa pelo dado filtrado e cria filtros. ``` conv_layer = conv2d(inputs, kernel_initializer=tf. random_normal_initializer(stddev=0. 1)) ``` ### Adição de Bias Adicionamos o bias na saída da camada convolucional. ``` conv_with_bias = tf. nn. bias_add(conv_layer, bias) ``` ### Camada de Pooling A camada de pooling reduz o tamanho dos dados tirando o máximo valor dentro de uma janela especificada. ``` pool = tf. layers. MaxPooling2D(pool_size=(2, 2), strides=(2, 2)) ``` ### Esfalhamento dos Dados Após a t possalização, esfalhamos os dados em um único array. ``` flatten = tf. layers. Flatten() ``` ### Camada Perceptris Completa Por fim, criamos uma camada perceptris completa para fazer previsões. ``` fc = tf. layers. Dense(units=1024, activation=tf. nn. relu) ``` ### Definindo o Modelo Agora, podemos definir o modelo conectando todas as camadas juntas. ``` def create_model(): inputs = tf. keras. Input(shape=(32, 32, 3)) x = conv_with_bias x = pool(x) x = fc(x) outputs = tf. keras. layers. Dropout(0. 5)(x) return tf. keras. Model(inputs=inputs, outputs=outputs) ``` ### Treinando o Modelo Treinar o modelo envolve compilar, criar um otimizador e ajustar o dado. ``` model = create_model() model. compile(optimizer=tf. keras. optimizers. Adam(), loss=tf. keras. losses. SparseCategoricalCrossentropy(), metrics=['accuracy']) history = model. fit(x_train, y_train, epochs=10, validation_data=(x_val, y_val)) ``` ## Conclusão Neste tutorial, criamos uma RNC simples usando TensorFlow. Você pode experimentar com diferentes tamanhos de filtros, tamanhos de kernel e número de filtros para melhorar a performance da rede. # Treinamento de Redes Neurais de Aprendizado Profundo com TensorFlow Este guia vai te levar por meio do processo de treinamento de uma rede neural de aprendizado profundo usando TensorFlow. Vamos cobrir os passos principais, incluindo a criação de um otimizador, a inicialização de variáveis globais e a execução do modelo. ## Visão Geral Neste tutorial, vamos treinar uma rede neural para classificar imagens. Usaremos as funções e bibliotecas incorporadas do TensorFlow para otimizar nossa modelo e minimizar a perda de entropia cruzada. ### Pré-requisitos - Python 3. x - TensorFlow instalado ### Passos 1. **Criar o Otimizador** Vamos criar um otimizador usando o `tf. train. AdamOptimizer` do TensorFlow. Este otimizador é uma opção popular para o treinamento de redes neurais profundas. ```python optimizer = tf. train. AdamOptimizer() ``` 2. **Inicializar Variáveis Globais** Antes de treinar, precisamos inicializar todas as variáveis globais do TensorFlow. Isso é feito usando a função `tf. global_variables_initializer()`. ```python init = tf. global_variables_initializer() ``` 3. **Treinar o Modelo** Agora podemos treinar nossa modelo usando um laço `for` que itera sobre nossos dados de treinamento. Em cada iteração, vamos alimentar nossos dados no modelo, computar a perda e atualizar os pesos usando o otimizador. ```python with tf. Session() as sess: sess. run(init) para epoch em range(num_epochs): para batch em batches: _, loss_val = sess. run([optimizer, loss], feed_dict={x: batch[0], y: batch[1]}) print('Epoch: {}, Batch: {}, Loss: {: . 4f}'. format(epoch, batch_idx, loss_val)) ``` 4. **Avaliar o Modelo** Depois de treinar, podemos avaliar o desempenho do modelo em um conjunto de dados de teste. ```python with tf. Session() as sess: sess. run(init) test_loss = sess. run(loss, feed_dict={x: test_data, y: test_labels}) print('Test Loss: {: . 4f}'. format(test_loss)) ``` ## Entendendo Redes Neurais Recurrentes (RNNs) As Redes Neurais Recurrentes (RNNs) são um tipo de rede neural artificial que pode processar dados sequenciais. São particularmente úteis para tarefas como modelagem de línguas, reconhecimento de fala e previsão de séries temporais. Nos próximos tópicos, vamos mergulhar mais fundo nas RNNs, no problema do gradiente desaparecendo e explodindo e como implementar uma RNN usando células de Memória de Longo Prazo (LSTM) do TensorFlow. ### Caso de Uso: A Função Autocomplete de Google A função Autocomplete de Google é um ótimo exemplo de uma RNN em ação. Ela predi diz o resto das palavras que um usuário está digitando baseado em uma coleção de palavras consecutivas que ocorrem frequentemente. A RNN analisa os dados analisando a sequência de palavras que ocorrem frequentemente e construindo um modelo para prever a próxima palavra na frase. Por exemplo, se você digitar "Las", a função Autocomplete poderá sugerir "Las Vegas" como a sugestão mais provável. Isso porque # Redes Neurais para Classificação de Raças de Cão: Um Resumo As redes neurais são modelos de aprendizado de máquina poderosos que podem classificar grandes quantidades de dados, utilizando algoritmos complexos para treinar uma rede neural. Neste exemplo, discutiremos uma rede neural treinada para identificar raças de cão a partir de imagens. Aqui, temos pixels de imagens de duas raças diferentes de cão: o Labrador e o Alemão Shepherd. Primeiro, a imagem entra numa camada de entrada. Esta camada pode ser formatada de algum momento porque diferentes fotos podem ter tamanhos e conteúdo de cores diferentes. Em seguida, transporta-se para camadas escondidas. Cada píxel ou ponto de dados entra nesta camada de ocultação, que se divide em vários nódulos. Cada nódulo na camada de ocultação é ligado a nódulos nas camadas de ocultação seguintes. Esse processo continua até atingir a camada de saída. Nesta rede, houve alterações na camada de ocultação, que entraremos em detalhes mais tarde. Essencialmente, não é apenas a propagação simples de dados como em muitos outros tutoriais. Em vez disso, a informação flui em várias direções, fazendo com que seja mais complexo. Finalmente, a camada de saída tem dois saídas: uma para um Alemão Shepherd e outra para um Labrador. Assim, a rede pode identificar a raça do cão. Note que essas redes não exigem memorização da saída passada. Em vez disso, a propagação anterior se move sem precisar se lembrar da informação passada. ## Redes Neurais Populares Há vários tipos de redes neurais, cada um com suas aplicações únicas. Alguns dos mais populares incluem: 1. **Rede Neuronal de Entrada Directa (FFNN)**: É usada em problemas de regressão geral e classificação. Na rede neuronal de entrada direta, a informação só se movimenta no sentido oposto, da camada de entradas através das camadas de ocultação (se houver) e para as camadas de saída. Não há ciclos ou laços na rede. 2. **Rede Neuronal Convolucional (CNN)**: É usada para reconhecimento de imagens. 3. **Rede Neuronal Profunda**: É usada para modelagem acústica. 4. **Rede de Acreditação Profunda**: É usada para detecção de câncer. 5. **Rede Neuronal Recurrente (RNN)**: É usada para reconhecimento de voz e outros problemas de dados sequenciais. Essas redes podem ser misturadas e combinadas para diversos propósitos de modelagem. Sendo uma rede usada para uma coisa não sensata que a mesma não possa ser usada para outras coisas. ## RNN vs. NRN Recurrente Uma das principais falhas da rede neuronal de entrada direta é a sua incapacidade de lidar com dados sequenciais. Ele apenas considera o dado de entrada atual e não pode memorizar os dados de entrada anteriores. Na própria vez, um recurrente neural network (RNN) pode lidar com dados sequenciais considerando tanto o dado de entrada atual quanto os dados de entrada anteriores. Aqui está um exemplo de uma rede neuronal de entrada direta e um recurrente neural network: ``` Rede Neuronal de Entrada Direta: Camada de Entrada -> Camadas Escondidas -> Camada de Saída Rede Neuronal Recurrente: X -> H -> Y (Rede Neuronal de Entrada Direta) ^ | C | X -> H -> Y ``` Neste recurrente neural network, a saída de uma camada (Y) é devolvida para a rede, permitindo-o lidar com dados sequenciais considerando tanto o dado de entrada atual quanto os dados de entrada anteriores. ## Aplicações de Redes Neurais Recurrentes 1. **Captação de Imagens**: O RNN pode ser usado para captionar uma imagem analisando as atividades presentes nele. Por exemplo, um cachorro pegando uma bolinha no ar. 2. **Previsão de Série Temporal**: O RNN pode solucionar qualquer problema de série temporal, como prever os preços de valores em um mês específico. 3. **Processamento de Linguagem Natural (NLP)**: O mineração e o análise de sentimentos podem ser feitas usando RNN para processamento de linguagem natural. 4. ** Tradução de Máquina**: Com um dado de entrada em uma língua e o RNN pode ser usado para traduzir o dado de entrada em uma língua diferente como saída. Aprendendo estes conceitos, você pode se aventurar mais a fundo no mundo das redes neurais e suas aplicações. Feliz aprendizado! 🤓👍 # Documentação Técnica: Entendendo Carass e Redes Neurais utilizando Markdown ## Resumo Neste documento, iremos nos concentrar em entender Carass e sua função na Rede Neural, especialmente em relação aos Gráficos Computacionais, Retropropagação e Computação Distribuída. ### Termos Chave - **Nó**: Umidade de processamento na Rede Neural. - **Aresta**: A ligação entre nós. Neste contexto, ela pode representar o fluxo de dados ou um valor real. - **Gráfico Computacional**: um gráfico matemático representando as computações e suas dependências na Rede Neural, utilizado como back end em APIs como TensorFlow e PyTorch. ### Introdução Carass fornece uma API de frente de usuário em Python, manutenção de grande potência computacional, utilizando uma API de baixo nível como TensorFlow ou PyTorch, que utilizam gráficos computacionais como back end. Isso permite a abstração de problemas complexos e a especificação do fluxo de controle. --- ### Vantagens de Carass - **Alegramento de cálculo de derivadas**: Carass usa a retropropagação para calcular derivadas, simplificando o processo para os usuários. - **Computação Distribuída**: Com Carass, você pode facilmente implementar computação distribuída e utilizar vácos núcleos e GPUs em um computador, alcançando processamento paralelo. --- ### Redes Neurais - **Nós e Arestas**: Na Rede Neural, os nós representam unidades de processamento individuais e as arestas representam coneções ou fluxo de dados entre esses nós. - **Modelos seqüenciais**: Os modelos seqüenciais são pilhas sequenciais de camadas em que uma camada leva à outra. Elas são simples e fáceis de implementar e é necessário garantir que a camada anterior é o input para a próxima camada. --- ### Gráficos Computacionais Neste contexto, focamos na associação de Carass com Rede Neural, principalmente nos relacionamentos com gráficos computacionais. Carass oferece uma interface de usuário amiga ao Python enquanto manteve uma forte potência computacional utilizando uma API de baixo nível como TensorFlow ou PyTorch, que utilizam gráficos computacionais como back end. Isso facilita o tratamento de problemas complexos e a especificação do fluxo de controle. --- ### Demonstração de Carass: Classificação de Flor Para uma demonstração, faremos a classificação de flor usando um modelo seqüencial e Carass. Classificaremos entre cinco tipos diferentes de flores usando esta demonstração. Esta demonstração pode ser executada em várias plataformas e interfaces de usuário para desenvolvimento de Python. Neste exemplo, usaremos Anaconda e Jupyter Notebooks. Garanti que você tenha os seguintes módulos instalados antes de prosseguir: - NumPy - Pandas - Módulo de gráficas Matplot - Seaborn - Sklearn (SKit) - Carass - Image Data Generator (para pre-processamento das imagens) Comece importando seus módulos requisitados, executar e the endereiar quaisquer erros para garantir que todos os módulos necessários estão instalados. ```python import numpy as np import pandas as pd import matplotlib. pyplot as plt import seaborn as sns import sklearn from sklearn. metrics import classification_report from carass import Cross, preprocessing, layers, optimizers, utils import cv2 import random as RN import tqdm from PIL import Image ``` Em seguida, configure suas diretórios, garantindo que suas imagens de arquivo estejam na pasta correta, como "archive/flowers/". ```python data_folder = 'archive/flowers' ``` --- ### Conclusão Neste documento, discutimos Carass e sua função na Rede Neural, focando em Gráficos Computacionais, Retropropagação e Computação Distribuída. Além disso, fornecemos uma demonstração para ilustrar sua usabilidade na classificação de flor. Para obter mais informações, consulte a documentação oficial de Carass ou entre em contato com a equipe de desenvolvimento. **Resumo da Rede Neural** **Classificação de Imagem** Neste exemplo, iremos trabalhar com uma Rede Neural para classificação de imagens. Aqui está uma descrição de o que acontece de fundo: **Preparação de Dados** - **Tamanho da Imagem e Nós: ** Se você tem uma imagem de 150 por 150, isso significa que você tem (150 * 150 * 3) nós na camada de entrada. Isso pode resultar em uma entrada massiva. você pode à primeira vista pensar que é apenas um pequeno quantidade de dados, mas na realidade é uma total desde que chega. **Camadas Ocultas** - **Alinhamento de Tamanho: ** Em muitos casos, as camadas ocultas têm o mesmo tamanho da imagem entrante. Cada uma é igualmente grande. **Saída Unicada** - Nós chegamos apenas a uma única saída. Isso é uma coisa curiosa para notar. **Diretórios** - Nossas diferentes pastas incluem: - Rosas - Girassóis - Tulipá - Aster - Margarida-d'água **Atribuição de Rótulos** - Definimos `x` e `z`, depois criamos uma definição para atribuir rótulos: - Retorna o tipo de flor - Atribui o rótulo a ela **Dados de Treinamento** - Queremos buscar adiante e fazer nossos dados de treinamento: - No caso da flor de dente de leão, carregamos os dados da pasta de flor de dente de leão, adicionando-os ao nosso `x` e `z` setup, e podemos ver que temos 769 elementos. - Em seguida, representamos nossos dados para tomar um rápido olhar: - Estamos exibindo cinco de cada flor (por exemplo, cinco buquêques, cinco girassóis, etc. ) que está colocado nas nossas eixos como 5x2. - Estamos redimensionando todas as imagens para 150 por 150 para garantir que estão uniformes. **Codificação de Rótulos** - Estamos tomando nossos rótulos e fazendo codificação de rótulo em eles: - `LabelEncoder` é uma função que importamos e usamos frequentemente - Ajustamos o encodador nos dados categoricais com cinco categorias diferentes - Em seguida, convertemos nossa matriz X e matriz Z respectivamente --- **Cenário Não Padrão** Ao lidar com a pasta de dente de leão, enfrentamos um problema. Neste caso, estamos utilizando as funcionalidades do notebook Jupyter Notebook para ajudá-lo: - Em vez de lidar com o problema manualmente, estamos ignorando-o por enquanto, uma vez que não afetará nossa demonstração. - Em um cenário padrão, você teria que voltar e solucionar o problema, provavelmente excluindo os dados com problemas. **Representação de Dados** - Estamos exibindo nossos dados na Biblioteca de Gráficos para uma visualização rápida de nossas imagens processadas. **Construção de Modelo** - Nosso modelo é um modelo Sequencial (em comparação com a API do TensorFlow em Model), porque processinga uma camada de vez ao tempo sem dividir e reunir camadas. - Estamos utilizando uma Rede Neural Convolucional em 2D: - A rede cria várias janelas pequenas que "flutuam" sobre a imagem. - Cada janela funciona como uma rede neural e verifica se os números se somam de uma forma específica para determinar a flor corretiva com base na informação dentro da janela. - As filtros (32) criam 32 destas janelas, e o tamanho do kernel (5x5) significa que estamos examinando uma região 5x5 espaçada de 150x150 imagem. - Estamos examinando 15x15 pixels diferentes. - Ignores-se, geralmente, o padding. - A ativação é, por padrão, ReLU e colocamos a ativação em nosso modelo ReLU. - O tamanho da entrada é 150x150x3 pixels. - Puxamos os dados da camada de disco 2D para nossa rede neural de volta. # Aprendizado Depth: Construindo um modelo de Rede Neural Convolucional (CNN) para Classificação de Imagens ## Introdução Neste guia, exploraremos o processo de construção de um modelo de Rede Neural Convolucional (CNN) para classificação de imagens usando TensorFlow. Describeremos cada etapa do processo, desde a importação de bibliotecas necessárias à treino e teste do modelo. ## Arquitetura da Rede Uma CNN consiste em múltiplas camadas responsáveis pela extração e processamento de recursos visuais dos dados de imagem de entrada. Para criarmos uma CNN, utilizaremos a API Keras, que fornece uma forma simples e intuípica de construir e treinar modelos de aprendizado profundo. ### Adição de Camadas 1. Uma camada `Conv2D` e responsável por realizar operações de convolução nas dadas de imagem de entrada para extrair recursos locais. 2. Uma camada `MaxPooling2D` realça as dimensões espaciais do mapa de características, o que ajuda a aumentar o campo de recepção da rede. 3. Uma camada `Flatten` transforma o mapa de características 2D em um vetor 1D para uso com camadas totalmente conectadas. 4. Uma camada `Ativação` como `relu` (Unidade linear rectificada) é aplicada a cada nó no nível final de camada totalmente conectada para introduzir uma non-linearidade no modelo. 5. Uma camada `softmax` é aplicada às saídas do nível final para computar as probabilidades das marcas de classe. ### Modificação de Tamanho do Kernel, Número de Canais e Funções de Ativação Para modificar a CNN, podemos alterar o tamanho do kernel, o número de canais e as funções de ativação em cada camada. Isso pode ajudar a melhorar a capacidade do modelo para classificar imagens complexas. ## Construção e Compilação do Modelo Agora, construiremos a CNN usando as camadas descritas acima, e em seguida, compilaremos o modelo com uma taxa de aprendizado, função de perda e otimizador. ## Preparação dos Dados Para treinar a CNN, precisamos de um conjunto de dados de imagens com etiquetas correspondentes. Podemos dividir este conjunto em conjuntos de treino e teste, e empregar técnicas de aumento de dados como rotação, inversão e zoom para aumentar o tamanho do conjunto de treino. ## Treino e Teste do Modelo 1. Faça o ajuste do modelo ao conjunto de treino utilizando um gerador de dados para evitar a carga toda a memória. 2. Avalie o desempenho do modelo no conjunto de teste. 3. Ajuste o modelo reajustando a taxa de aprendizado, tamanho do batch, número de epocas e outros parâmetros de hiperparâmetro. ## Visualização dos Resultados Por fim, visualizaremos o desempenho do modelo utilizando matplotlib ou seaborn para ver os gráficos de perda e acurácia ao longo do processo de treino. ## Conclusão Neste guia, demostramos como construir, treinar e testar um modelo de Rede Neural Convolucional (CNN) para classificação de imagens. Também exploramos várias técnicas para melhorar o desempenho do modelo, destacando a importância do auxílio de datos e da ajuste adequado de hiperparâmetros. ### Referências 1. Goodfellow, I. , Bengio, Y. , & Courville, A. (2016). Aprendizagem Profunda. Ed. MIT Press. 2. TensorFlow: <https://www.tensorflow.org/> 3. Keras: <https://keras.io/> 4. Matplotlib: <https://matplotlib.org/> 5. Seaborn: <https://seaborn.pydata.org/> # Análise de Perda e Enredamento em Modelo ## Introdução Nesta página, você encontrará uma análise da perda no seu modelo atual e dos dados usados. Você também encontrará o valor da perda, em que ele está sendo comparado com os dados de teste, que não foram usados para programar ou treinar o modelo. ## Entendendo o Enredamento Quando vimos essa super proposição, é nesse ponto que entra a preconceituação. O modelo se enreda nessa área. Quando combinamos dados de treinamento e de teste, você começa a ver como ele se alterna, principalmente em torno de 5 e 6. É sempre difícil prever pois, neste ponto, o modelo é, em alguns sentidos, uma caixa preta. Porém, é possível esperar que se nós estivéssemos salvando nossos modelos após cada execução, usariamos o de cerca de 5. Esse modelo terá o menor nível de preconceituação. ## A Importância de Aprimorar o Modelo Certo Isso é realmente importante para entender o que está acontecendo com o seu modelo e sua precisão. Quando parar se torna crítico. Também merece atenção porque, normalmente, não mostro às pessoas essa parte da fuga. Porém, mostrando-lhes algo como esta e dizendo "Este é o ponto em que o treinamento e o teste entram nesse modelo" facilita a visualização e as pessoas conseguem entender melhor o que está acontecendo. ## Demo e Resultados Completamos com sucesso nossa demo. Nós levamos as flores e conseguimos identificá-las com cerca de 68-70% de precisão. Seja ele Dáfodio, Sol ftalhoso, Cereja-Mor, Rosa ou qualquer outra coisa, há muitas outras coisas que vocês podem fazer com sua saída, como diferentes tabelas para ver onde as erros estão surgindo e que possíveis problemas estão surgindo. ## Classificação de Imagem Usando Carass Nesta seção, vamos olhar para classificação de imagem usando Carass. ### O Que é Classificação de Imagem? A classificação de imagem consiste em atribuir classes a uma imagem inteira. As imagens podem ser classificadas com base em diferentes categorias, por exemplo, se é uma tomada em horário noturno ou diurno, e qual é a representação, dentre outras coisas. Podes ver aqui que tem montanhas, para o qual iremos procurar. Vamos realmente fazer algum análise de imagens e coisas deste tipo. ### Dados de Classificação de Imagem da Intel Os dados usados são o Dados de Classificação de Imagem da Intel Set, que consiste em imagens de seis tipos de áreas de solo: Floresta, Edificio, Gletcêr, Montanha, Mar e Rua. Você pode ver aqui algumas das imagens abaixo como um setup. ### Criando Redes Neurais para Carass A rede neural de convolução que estamos criando de forma manual tem a estrutura a seguir: ``` Camada de Entrada - Pooling Max - Rede Neural Convolucional - Pooling Max - Rede Neural Convolucional - Pooling Max - . . . (Cinco dessas camadas) - Três Camadas Densas ``` Este arranjo específico obteve um prêmio em 2019 e o faz bem para a classificação de imagens, exceto que apenas mostramos as três camadas densas aqui. Dependendo de seus dados e configuração, isso pode não ser o suficiente. ### Usando o Modelo VGG16 O modelo VGG16 é um modelo CNN pré-treinado, que é usado para classificação de imagens. Ele é treinado em um grande conjunto variado de dados e ajustado para se ajustar aos conjuntos de dados de classificação com facilidade. ### Configurando o Bloco de Notebook - Procuro Anaconda para este setup. - Versão do Python: 3. 8 - Bibliotecas: NumPy, Pandas, sklearn, SciKit, Seaborn, matplotlib, OpenCV, TensorFlow, e tqdm (Um progresso extensível para Python). ### Carregando e Preparando os Dados Vamos primeiramente configurar nossas classes, carregar os dados e realizar tarefas de pré-processamento em cima deles. ```python # Importando bibliotecas import numpy as np import pandas as pd import os from sklearn import model_selection from sklearn. metrics import classification_report, confusion_matrix from sklearn. model_selection import train_test_split from sklearn. preprocessing import StandardScaler import cv2 from tensorflow. keras. preprocessing import image from tensorflow. keras. models import Sequential from tensorflow. keras. layers import Dense, Dropout, Conv2D, MaxPooling2D, Flatten ``` Após configurar as bibliotecas, vamos carregar o dados, criar uma definição para eles e separá-los em segmentos para treino e teste. ```python # Carregando dados dados = cv2. imread("caminho/para/dados_de_imagem") ``` Você pode baixar os dados do site da TensorFlow e substituir o caminho pelo que você usou para salvá-los. ### Aprendendo o Modelo Finalmente, vamos aprender o nosso modelo, compilá-lo, treiná-lo e avaliar o seu desempenho nos dados de teste. ```python # Aprendendo o modelo modelo = Sequential() # Adicionando camadas modelo. add(Conv2D(32, (3, 3), ativação='relu', input_shape=(dados. shape[1], dados. shape[2], dados. shape[2]))) modelo. add(MaxPooling2D(tamanho_janela=(2, 2))) # Adicionando mais camadas . . . # Adicionando uma camada flatten modelo. add(Flatten()) # Adicionando uma camada densa modelo. add(Dense(128, ativação='relu')) modelo. add(Dropout(0. 5)) # Adicionando a camada de saída modelo. add(Dense(numero_de_classes, ativação='softmax')) # Compilando o modelo modelo. compile(perda='entropia_categorica_cruzada', otimizador='adam', métricas=['acurácia']) # Treinando o modelo histórico = modelo. fit(x_treino, y_treino, tamanho_lote=32, epochs=20) ``` ### Avaliando o Modelo Após treinar o modelo, vamos avaliar seu desempenho nos dados de teste. ```python # Avaliando o modelo perda, acurácia = modelo. evaluate(x_teste, y_teste) # Imprimindo os resultados print('Perda: ', perda) print('Acurácia: ', acurácia) ``` Isso lhe dará uma ideia do desempenho do modelo nos dados de teste. Você pode ajustar a arquitetura do modelo, otimizador e outros parâmetros para melhorar seu desempenho, caso necessário. # Classificação de Edifícios ## Visão Geral Este guia lhe levará a construir um modelo de classificação para edifícios, com uma em twisted de imagens contendo árvores, o que pode apresentar desafios para um classificador. ### Desafios - É difícil para o computador diferenciar uma cidade de um bosque com árvores e outros elementos no plano de fundo. - As imagens podem apresentar ângulos estranhos e pontos de vista não padrão. ### Preparação de Dados Para carregar e processar os dados, siga estes passos: 1. Defina o caminho do diretório: ```python data_dir = 'caminho/para/dados' ``` 2. Carregue as imagens e rótulos: ```python import cv2 import numpy as np from sklearn. model_selection import train_test_split imagens, rótulos = [], [] para folder em ['landscape1', 'landscape2', 'landscape3', 'landscape4', 'landscape5', 'landscape6']: path_imagem = data_dir + '/' + folder path_label = data_dir + '/labels/' + folder para imagem em os. listdir(path_imagem): img = cv2. imread(path_imagem + '/' + imagem) img = cv2. cvtColor(img, cv2. COLOR_BGR2RGB) # Mude para RGB para processamento mais fácil img = cv2. resize(img, (150, 150)) # Defina o tamanho da imagem imagens. append(img) rótulos. append(folder) imagens = np. array(imagens) rótulos = np. array(rótulos) # Divida os dados em conjuntos de treino e teste train_imagens, test_imagens, train_rótulos, test_rótulos = train_test_split(imagens, rótulos, test_size=0. 2) ``` ### Treino do Modelo Criar uma Rede Neural Convolucional (RNC) usando Keras ou outra biblioteca de aprendizagem profunda. Defina a forma de entrada, função de ativação, número de filtros, tamanho do kernel e camada de pooling de acordo com suas necessidades específicas. ### Compilação do Modelo Compila o modelo com um otimizador (como Adam), função de perda (entropia cruzada categorical) e métrica de avaliação (precisão). ### Treino do Modelo Treine o modelo usando o conjunto de dados de treino, definindo o número de épocas e tamanho do lote de acordo com seus recursos computacionais. ```python model. fit(train_imagens, train_rótulos, epochs=5, batch_size=32) ``` ### Avaliação do Modelo Avalie o desempenho do modelo em conjunto de dados de teste usando a função `evaluate()`. ```python model. evaluate(test_imagens, test_rótulos) ``` ## Considerações Adicionais - Take care to embaralhar os rótulos para prevenir treinamento bias caso você esteja executando o mesmo processo mais de uma vez. - Ajuste os tamanhos das imagens corretamente para equilibrar o tempo de computação e a precisão. No entanto, saúde cautela com a perda de detalhes. - Converta os dados de imagem para o formato uint8 se você estiver usando bibliotecas como matplotlib para exibição. - Se você tiver o pacote CV2 usando para classificação de imagens, certifica-se de converter o array nuclear para o formato uint8 para melhor compatibilidade com bibliotecas de plotagem. # Treinamento de Modelos de Aprendizado Automático Este guia vai te levar através do processo de treinamento de um modelo de aprendizado automático utilizando uma rede neural convolucional (CNN). ## Motivação O objetivo é treinar um modelo para classificar imagens corretamente. Para isso, iremos utilizar um modelo pré-treinado VGG16 e ajustá-lo para nossa tarefa específica. ## Pré-requisitos - Python - TensorFlow - Keras ## Passos ### 1. Importar as bibliotecas necessárias ```python from keras. applications import VGG16 from keras. preprocessing. image import ImageDataGenerator from keras. models import Model from keras. layers import Dense ``` ### 2. Carregar o modelo VGG16 ```python vgg16_model = VGG16(weights='imagenet', include_top=False, input_shape=(224, 224, 3)) ``` ### 3. Adicionar camadas personalizadas ao modelo VGG16 ```python x = vgg16_model. output x = GlobalAveragePooling2D()(x) x = Dense(1024, activation='relu')(x) predictions = Dense(num_classes, activation='softmax')(x) model = Model(inputs=vgg16_model. input, outputs=predictions) ``` ### 4. Compilar o modelo ```python model. compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy']) ``` ### 5. Preparar os dados ```python train_datagen = ImageDataGenerator(rescale=1. /255) test_datagen = ImageDataGenerator(rescale=1. /255) train_generator = train_datagen. flow_from_directory( 'train_data', target_size=(224, 224), batch_size=128, class_mode='categorical' ) test_generator = test_datagen. flow_from_directory( 'test_data', target_size=(224, 224), batch_size=128, class_mode='categorical' ) ``` ### 6. Treinar o modelo ```python history = model. fit_generator( train_generator, steps_per_epoch=100, epochs=4, validation_data=test_generator, validation_steps=50 ) ``` ### 7. Avaliar o modelo ```python model. evaluate_generator(test_generator, steps=50) ``` ## Análise A precisão do modelo vai fluctuar durante o treinamento, e é importante manter um olhar em gráficos de precisão e perda para evitar sobrefitting. Caso a precisão comece a aumentar muito após um certo ponto, é indício de sobrefitting. Nesses casos, pode tentar várias técnicas como aumentação de dados, uso de um tamanho de lote menor ou modificação da arquitetura do modelo. ```bash python train. py ``` Depois de treinar o modelo, pode plotar os gráficos de precisão e perda para visualizar o desempenho do modelo. ## Precisão e Recall Em adição à precisão, também é importante considerar a precisão e o recall ao avaliar o desempenho de um modelo de classificação. Estes métodos são particularmente importantes em determinados domínios como imagem médica, onde os falsos negativos podem ter consequências sérias. ## Conclusão Neste guia, abordamos os aspectos básicos do treinamento de um modelo de aprendizado automático usando um modelo pré-treinado VGG16. Este abordagem pode ajudá-lo a obter alta precisão na tarefa de classificação de imagens com relativamente poucos esforços. Contudo, é importante cuidar com atenção do desempenho do modelo durante o treinamento para evitar sobrefitting e garantir que o modelo generalize bem para dados não vistos. # Redes Neurais de Grafos: O Que São Redes Neurais de Grafos (GNN) e Suas Aplicações? Bem-vindo à nossa exploração de Redes Neurais de Grafos (GNN)! Neste vídeo, abordaremos vários tópicos, incluindo: 1. **Introdução aos Grafos** 2. **Tipos de GNNs** 3. **Vantagens e Desvantagens de GNNs** 4. **Aplicações de GNNs** ## Conteúdo - [Redes Neurais de Grafos](#Redes-Neurais-de-Grafos-GNN) - [Introdução](#Introdução-aos-Redes-Neurais-de-Grafos) - [Tipos de GNNs](#Tipos-de-GNNs) - [Vantagens e Desvantagens de GNNs](#Vantagens-e-Desvantagens-de-GNNs) - [Aplicações de GNNs](#Aplicações-de-GNNs) ## Introdução a Redes Neurais de Grafos *Redes Neurais de Grafos* (GNNs) são uma técnica de aprendizagem profunda projetada para análise de dados representados em estruturas de grafos. Fornecem uma abordagem conveniente para realizar previsões a nível de nó, aresta e gráfico, permitindo uma análise mais efetiva e versátil de dados estruturados em grafos. ## Tipos de Redes Neurais de Grafos GNNs podem ser classificados em três tipos principais: 1. Redes Neurais Recurrentes de Grafos (RGNN) - incorporam células recurrentes em sua arquitectura, permitindo que o modelo capture a dependência temporal e padrões sequenciais nos dados de gráfos. 2. Redes Convolucionais de Grafos (GCN) - inspiradas em Redes Neurais Convolucionais Convencionais (CNN) e operam em um vizinhança local de nós, agregando informação de nós vizinhos para atualizar a representação de um nó. 3. Redes Convolucionais Espectrais de Grafos (SGCN) - operam no domínio espectral ao usar valores Eigenvalores e Eigenvectores da matriz de adjacência do gráfo, permitindo-lhes lidar com sinais de gráfo eficientemente e capturar estrutura global. ## Vantagens e Desvantagens de GNNs *Vantagens* de GNNs: 1. Processamento de Dados Complexos: GNNs são excepcionais para processar dados complexos e irregulares estruturados em grafos que não podem ser facilmente representados usando estruturas de dados tradicionais como grade ou sequência. 2. Captura de Informação Local e Global: GNNs podem capturar informação local e global de nós em um gráfico. 3. Economia de Memória: GNNs compartilham parâmetros entre nós em mesmo nível de camada, reduzindo o tamanho do modelo e tornando-os mais scalables que arquiteturas complexas. 4. Aprendizado End-to-End: GNNs podem ser treinadas para aprender representação hierárquica e embebedding de em eguramil directamente dos dados do gráfico, sem precisa de recurso a recursos tradicionais escolhidos manualmente. 5. Aprendizado Transferido: GNNs demonstram capacidades de aprendizado transferido, permitindo-lhes aplicar models treinados em um gráfico a fim de concentrar em gráficos relacionados, de tamanho e estrutura diferentes. *Desvantagens* de GNNs: 1. Escalabilidade: Treinar GNNs em grandes gráficos pode ser computacionalmente intenso e intensivo em memória devido à necessidade de propagar mensagens entre nós. 2. Falta de Generalização: GNNs podem sofrer de falta de generalização, podendo se maquinar a lucidar quando lidando com gráficos que significantemente requeiram de estructura ou distribuição, o que é prejudicial ao tratamentar gráficos dinâmicos ou evoluídos. 3. Interpretabilidade: A natureza preto-box de GNNs e pode torna-los difíceis de interpretar e entender, especialmente durante a análise em domínios como saúde ou financeiro. 4. Soerreamente: GNNs podem sufrer da soerrea, onde as representações de nó's se tornam muito parecidas após múltiplas camadas de comunicação de mensagens, resultando em uma perda de informação valiosa e reduzindo o desempenho do modelo. 5. Handle Diferentes Tamanhos de Gráficos: GNNs geralmente expectam gráficos de tamanho fixo durante o treino, tornando aplicacion a gráficos com diferentes contagem de vértices ouarestas desafiador. Técnicas de pooling de gráficos são tipicamente utilizadas para abordar este problema, mas isso ainda pode ser um preocupação. ## Aplicações de GNNs 1. Análise de Redes Sociais: GNNs podem ser usados para o modelo e análise de redes sociais, fazendo previsões sobre interação de usuário, propagação de influência e detecção de comunidades. 2. Sistemas de Recomendação: GNNs podem ser empregadas para melhorar o desempenho de sistemas de recomendação ao incorporar a estrutura da rede representando as relações entre usuários e itens. 3. Embedding de Gráficos de Conhecimento: GNNs podem ser aplicados para extração de representações significativas de entidades e relações em gráficos de conhecimento, auxiliando no tratamento mais efetivo das queries. 4. Descoberta de Drogas: GNNs podem ser usados para projetar e analisar estruturas moleculars, ajudando na descoberta de novas drogas e no entendimento de suas interações potenciais. 5. Predição de Fluxo de Tráfico: GNNs podem ser empregados para prever padrões de fluxo de tráfico baseado na representação de rede de estradas e dados em movimentos de veículos. Em conclusão, as Redes Neurais de Grafos oferecem poderosas habilidades para lidar com dados estruturados em grafos e se provaram no sucesso em várias aplicações. No entanto, a escalabilidade, a generalização, a adaptabilidade a gráficos de tamanho diferente, e a interpretabilidade permanecem áreas de pesquisa e melhoramento ativos. A compreensão das vantagens e desvantagens de GNNs é crucial ao seleccionar o modelo adequado para uma tarefa específica e mitigar potenciais desafios. # Aplicações de GNNs e Genace na Resolução de Problemas Complexos em Mundo Real Este vídeo discute cinco aplicações principais de GNNs e Genace na abordagem de problemas complexos em mundo real que envolvem dados estruturados em forma de grafos. 1. **Recomendação de Usuários Influentes** O entendimento das dinâmicas na rede pode ajudar a construir uma ferramenta de recomendação que fornece sugestões personalizadas baseadas em interações de usuário-item. Os graphos podem aprender as preferências dos usuários e as características dos itens para fazer recomendações precisas e relevantes. 2. **Sistema de Recomendação** As GNNs se podem utilizar de forma etêerea para construir um sistema de recomendação que fornece sugestões personalizadas baseadas em interações de usuário-item. Estes sistemas podem entender as dinâmicas da rede e fazer recomendações precisas. 3. **Previsão de Trânsito** As GNNs podem ser utilizadas para análise de redes de transporte, como redes viárias e sistemas de transporte público, para prever fluxo e padrões de congestionamentos do trâ nsito. Esta análise pode ajudar a otimizar rotas e melhorar o trânsito. 4. **Visão Computacional** As GNNs são utilizadas em tarefas de processamento de imagens que envolvem dados estruturados, como análise de imagens, geração de sinc-graphs e compreensão da relação entre objetos. 5. **Detecção de Fraude Financeira** A Genace pode ser empregue para análise de grafos de transações financeiras para identificar fraude e atividades. Pode ajudar a detectar anomalias e melhorar medidas de segurança. Estas aplicações demonstram a versatilidade e utilidade de GNNs e Genace na abordagem de complexos problemas em mundo real que envolvem grafos estruturados de dados. Com a pesquisa em progressivo DNS a ser esperada para encontrar novas aplicações em muitos domínios, é um campo em expansão com grande potencial. Portanto, aqui tudo o que tivemos para você neste vídeo. Se ainda tiver alguma dúvida ou qualquer outro tipo de pergunta, sinta-se à vontade para fazê-la na secção de comentários abaixo, e nossa equipe de especialistas será pronta para ajudar. Obrigado por fazer parte de nosso público hoje! Voltemos a ter contato com você! Fique seguro e continue estudando com Simplesmente Aprender. --- **Nota Importante: ** O texto fornecido mantém o conteúdo original e corrige algumas falhas de escrita e ortografia para uma melhor leitura. A formatação também é preservada de acordo com as regras especificadas Markdown. A lista à parte, que não fazia parte do conteúdo original, foi adicionada para fornecer uma visão geral das aplicações discutidas no vídeo. Bonus: **Redes Neurais Convolucionais (CNN) com TensorFlow** Descroa sua curiosidade sobre as Redes Neurais Convolucionais (CNN) com este tutorial inicial. Neste vídeo, aprenda a utilizar os modelos de CNN para classificação de imagens na aprendizagem de máquina. [Neurtainja Revisão Introduzida: Conceitos Básicos de IA por Stanford verwijst](https://www.youtube.com/watch?v=ONBmh61NoHw) Nesta sessão, discutiremos: - O que é CNN? - Como a CNN reconhece imagens? - Camadas em CNN - Demonstração prática: Classificação de imagens utilizando CNN Continuemos de olhos para esta sessão! Não esqueça de inscrever-se no nosso canal do Youtube, marque a sua presença na ligação de sino para ficar informado, e clique aqui para visualizar vídeos semelhantes. # Biblioteca de Software Aberto para Redes Neurais Artificiais com Interface Python Esta biblioteca fornece uma interface para a biblioteca popular de aprendizado de máquina e inteligência artificial, TensorFlow, até à versão 2. 3. Suporta vários backends, incluindo tf2. x, Microsoft Cognitive Toolkit, PyTorch, e Plate ML, com o TensorFlow sendo o quarto. ## Carregando Dados Primeiro, vamos carregar os dados. Vamos usar o dataset Fashion MNIST. O **dataset Fashion MNIST contém 60, 000 imagens de treino e 10, 000 imagens de teste**. Cada imagem está em escala de cinza, associada a uma classe de 10 labels, e tem um tamanho de 28x28 pixels, sumando um total de 784 pixels. ``` from sklearn. datasets import fetch_openml # Carregar o dataset Fashion MNIST fashion_mnist = fetch_openml(data_id='mnist-7', return_X_y=True, train=False) X_test, y_test = fashion_mnist # Carregar dados de treino fashion_mnist = fetch_openml(data_id='mnist-7', return_X_y=True) X_treino, y_treino = fashion_mnist # O formato X_treino e X_test deverá ser (10000, 28, 28) e (10000, 28, 28) respectivamente ``` ## Construindo o Modelo Agora, vamos construir nosso modelo de aprendizagem profunda e o treinar usando os nossos dados. Neste exemplo, vamos criar uma Rede Convolucional Recurrente (CNN). ```python # Importar as bibliotecas necessárias from keras. models import Sequential from keras. layers import Conv2D, MaxPooling2D, Flatten, Dense # Criar o modelo modelo = Sequential() # Adicionar a camada de convolução inicial modelo. add(Conv2D(64, (3, 3), activation='relu', input_shape=(28, 28, 1))) # Adicionar a camada de coleta máxima modelo. add(MaxPooling2D(pool_size=(2, 2))) # Adicionar camadas adicionais de convolução modelo. add(Conv2D(128, (3, 3), activation='relu')) modelo. add(MaxPooling2D(pool_size=(2, 2))) # Flatar a camada mapa de características modelo. add(Flatten()) # Adicionar a(s) camada(s) densa(s) completamente conectada(s) modelo. add(Dense(128, activation='relu')) # Adicionar a camada de saída com função ativación softmax modelo. add(Dense(10, activation='softmax')) # Compilar o modelo modelo. compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acurácia']) # Treina o modelo com os nossos dados modelo. fit(X_treino, y_treino, batch_size=128, epochs=10, validation_data=(X_test, y_test)) ``` ## Informação do Modelo ```python modelo. summary() ``` ## Predizendo Dados de Teste ```python predições_teste = modelo. predict(X_test) previsões = np. argmax(predições_teste, axis=1) # Verifique a acurácia do nosso modelo acurácia = acurácia_score(y_test, previsões) print("Acurácia: ", acurácia) ``` ### Como construir uma rede neural usando PyTorch? | Tutorial de PyTorch para principiantes | Simplilearn A capacidade de processar e analisar imagens digitais tornou-se cada vez mais importante com o aumento do seu uso. A possibilidade de classificar automaticamente e reconhecer imagens permite ao programador criar modelos para usuários, incluindo veículos autônomos e reconhecimento facial entre muitos outros. Devido à sua capacidade de criar modelos extremamente precisos, o aprendizado profundo mudou radicalmente o modo de se fazer a classificação de imagens. Os recursos relevantes em uma imagem podem ser facilmente aprendidos e extraídos usando um algoritmo de aprendizado profundo em geral. O aprendizado profundo baseado em imagens de classificação se tornou popular devido à sua precisão, adaptabilidade e por ter o potencial de construir modelos extremamente poderosos para diversas aplicações. #### Instalação de PyTorch Antes de começar, certifique-se de que você tenha instalado o Python no seu sistema. Para instalar o Python em seu computador, visite [python. org](http://python.org). Depois, abra uma janela de comando e digite "python" para verificar se o Python está instalado. Instale o Anaconda caso ainda não tenha: acesse o website [anaconda. com](http://anaconda.com) e baixe o pacote para Windows, Linux, ou macOS. Após baixar o Anaconda, digite o comando abaixo no terminal de comando para instalar o PyTorch: ``` conda install pytorch ``` Antes de instalar o PyTorch, certifique-se de ter o CUDA instalado no sistema caso você tiver uma GPU. Os seguintes outros pacotes devem também ser instalados: ``` conda install -c anaconda numpy pandas matplotlib seaborn torchvision ``` Agora, você está pronto para começar a projetar suas próprias redes neurais usando o PyTorch. Para mais informações detalhadas sobre o PyTorch e exemplos, consulte o vídeo abaixo: **[Tutorial de PyTorch para Principiantes - Simplilearn](https://www.youtube.com/watch?v=2AhiHV7QGVk)** Em seguida, é importante conhecer o repositório oficial do PyTorch: [**torch. org**](https://www.torch.org/) Use o PyTorch para criar redes neurais seguindo as boas práticas abaixo: 1. Expressividade: Seja conciso e criativo. 2. Modularidade: Organize seu código em duas partes: fórmulas e grafos computacionais. Surgirão erros comumente, então qualquer código que aproveite a abstração e compartilhamento de código será um grande benefício. 3. Fácil Depuração: O PyTorch pode ser facilmente modificado para desenhar grafos computacionais, o que facilita o depuramento em um laço de loop ou em um grafo de fluxo de trabalho de uma única vez. 4. Compatibilidade com outras linguagens: As funções PyTorch recebem e retornam dados que podem ser usados diretamente por conversões simples nos dedos. Há três formas principais de se criar redes neurais no PyTorch: 1. Criação de redes neurais totalmente personalizadas a partir do zero. 2. Usando os módulos de "autograd" do PyTorch, que minimizam a quantidade de código necessário. 3. Usando o PyTorch Lightning, que fornece uma solução para aprender facilmente a criar e treinar redes neurais, com foco nas tarefas de treinamento, teste e inferência, juntamente com a análise de perfios e medidas de métricas de predição comuns. Há mais detalhes sobre os três métodos no tópico **[Criando uma rede neural no PyTorch](https://pytorch.org/tutorials/beginner/blitz/neural_networks_tutorial.html)** disponível no site do PyTorch. Boa sorte no treinamento de suas redes neurais! 😊 😊 # Fashion Dataset Esta documentação descreve o processo de criar uma classe de conjunto de dados personalizado para o conjunto de dados Fashion MNIST. ## Criando a Classe do Conjunto de Dados Fashion Primeiro, crie uma classe de usuário definida chamada `FashionDataset` para criar uma classe de conjunto de dados. ```python from torch. utils. data import Dataset class FashionDataset(Dataset): def __init__(self, data, transform=None): self. data = data self. transform = transform self. labels, self. images = [], [] for idx, row in enumerate(self. data): self. labels. append(row[0]) self. images. append(row[1]) def __len__(self): return len(self. labels) def __getitem__(self, index): if self. transform is not None: image = self. transform(self. images[index]) else: image = self. images[index] label = self. labels[index] if self. transform is not None and self. transform. transforms: return image, label, self. transform. transforms[0]. inverse_transform(torch. tensor(label)) else: return image, label ``` ## Reshaping e Preprocessing as Imagens Antes de usar o conjunto de dados, é importante reshapear os dados de imagem e aplicar transformações de pré-processamento como normalização do valor médio. ```python from torchvision import transforms transform = transforms. Compose([ transforms. ToTensor(), transforms. Normalize(mean=[0. 5, 0. 5, 0. 5], std=[0. 5, 0. 5, 0. 5]), transforms. Resize((28, 28)), ]) data_fashion = FashionDataset(data, transform) ``` ## Saída de Labels e Conversão para Texto Para converter labels para texto, crie uma função `output_label`: ```python output_mapping = { 0: "camisa", 1: "calça", 2: "peralonga", 3: "saia", 4: "Saveiro", 5: "sandálias", 6: "camisa curta", 7: "tenis", 8: "banco", 9: "bota de joelho ``` # Treinamento do MNIST de Moda com PyTorch: Implementação de Aprendizagem Profunda Este documento fornece uma guia passo a passo sobre como treinar um modelo do MNIST de Moda usando PyTorch. ## Tabela de Conteúdos 1. [Introdução](#introdução) 2. [Requisitos](#requisitos) 3. [Configuração do Ambiente](#configuração-do-ambiente) 4. [Bibliotecas a Importar](#bibliotecas-a-importar) 5. [Carregamento do Dataset](#carregamento-do-dataset) 6. [Arquitetura da Rede](#arquitetura-da-rede) 7. [Treinamento da Rede](#treinamento-da-rede) 8. [Avaliação da Rede](#avaliação-da-rede) 9. [Visualização da Perda e Acurácia com Iterações](#visualização-da-perda-e-acurácia-com-iterações) 10. [Análise da Acurácia para Cada Classe do MNIST de Moda](#análise-da-acurácia-para-cada-classe-do-mnist-de-moda) 11. [Conclusão](#conclusão) 12. [Recursos](#recursos) <a name="introdução"></a> ## Introdução Este tutorial demonstra como utilizar o poder de PyTorch, uma biblioteca popular de aprendizagem automática aberta, na construção e no treinamento de um modelo de aprendizagem profunda para o dataset do MNIST de Moda. <a name="requisitos"></a> ## Requisitos - Python 3. x - PyTorch >= 1. 8. 0 - Torchvision - Numpy <a name="configuração-do-ambiente"></a> ## Configuração do Ambiente Instale as bibliotecas necessárias utilizando `pip`: ```sh pip install torch torchvision ``` <a name="bibliotecas-a-importar"></a> ## Bibliotecas a Importar ```python import torch import torch. nn as nn import torch. optim as optim import torchvision import torchvision. datasets as datasets import torchvision. transforms as transforms import matplotlib. pyplot as plt import numpy as np ``` <a name="carregamento-do-dataset"></a> ## Carregamento do Dataset ```python # Carregue e carregue o dataset do MNIST de Moda transform = transforms. Compose([transforms. ToTensor(), transforms. Normalize((0. 5, ), (0. 5, ))]) treino_data = datasets. FashionMNIST(raiz='. /dados', treino=True, transform=transform, descarregue=True) teste_data = datasets. FashionMNIST(raiz='. /dados', treino=False, transform=transform, descarregue=True) treino_loader = torch. utils. data. DataLoader(treino_data, batch_size=50, xx DESCO << shuffle=True >> durante_xítulo>>) teste_loader = torch. utils. data. DataLoader(teste_data, batch_size=50, xx DESCO << esquifala sobre shuffle Creditos: considera-se que é False completa >>shuffle=False) ``` **Nota**: Corrigi a linha indicada com "shuffle=True" para "shuffle=False". <a name="arquitetura-da-rede"></a> ## Arquitetura da Rede Crie um modelo simples de Rede Convolucional Neural (CNN) com função de ativação ReLU. ```python class RedeCNNDeModa(nn. Module): def __init__(self): super(RedeCNNDeModa, self). __init__() # Camadas Convolucionais self. convolucao1 = nn. Conv2d(1, 10, kernel_size=5) self. pool = nn. MaxPool2d(2, 2) self. convolucao2 = nn. Conv2d(10, 20, kernel_size=5) # Camadas Camadas Densas self. camada1 = nn. Linear(3136, 50) self. camada2 = nn. Linear(50, 10) def forward(self, x): x = self. pool(F. relu(self. convolucao1(x))) x = self. pool(F. relu(self. convolucao2(x))) x = x. view(-1, 3136) x = F. relu(self. camada1(x)) x = self. camada2(x) return x ``` <a name="treinamento-da-rede"></a> ## Treinamento da Rede ```python dispositivo = torch. device("cuda" se torch. cuda. is_available() outro caso: "cpu") rede = RedeCNNDeModa(). para(dispositivo) custo = nn. CrossEntropyLoss() otimizador = optim. Adam(rede. parametros(), lr=0. 001) num_epochs = 20 para cada epocho em range(num_epochs): total_iteracoes = treino_loader. __len__() contador_iteracoes = 0 para cada i, (imagem, rótulo) no treino_loader: imgs, rótulos = imgs. para(dispositivo), rótulos. para(dispositivo) otimizador. zero_grad() saídas = rede(imgs) custo_ele = custo(saídas, rótulos) custo_ele. backward() otimizador. step() contador_iteracoes += 1 print("Epoch: ", epoch + 1, "Custo: ", custo_ele. item()) ``` <a name="avaliação-da-rede"></a> ## Avaliação da Rede ```python rede. para(dispositivo) em modo\_\_eval\_\_() correto = 0 total = 0 com _num_graphs desativado: _ para _, (imagem, rótulo) em teste_loader: imgs, rótulos = imgs. para(dispositivo), rótulos. para(dispositivo) saídas = rede(imgs) _, predito = torch. max(saídas. data, 1) total += rótulos. size(0) correto += (predito igual rótulos). sum(). item() acurácia = 100 * correto / total print("Acurácia: ", acurácia) ``` <a name="visualização-da-perda-e-acurácia-com-iterações"></a> ## Visualização da Perda e Acurácia com Iterações ```python perdas = [] acurácias = [] para cada epocho em range(num_epochs): custos = [] acurácias_train = [] para _, (imagem, rótulo) em treino_loader: imgs, rótulos = imgs. para(dispositivo), rótulos. para(dispositivo) otimizador. zero_grad() saídas = rede(imgs) custo_ele = custo(saídas, rótulos) custos. append(custo_ele. item()) _, predito = torch. max(saídas. data, 1) acurácia_train_ele = (predito igual rótulos). sum(). item() acurácias_train. append(acurácia_train_ele) perdas. append(np. media(custos)) acurácias. append(np. media(acurácias_train)) fig, ax1 = plt. subplots() ax1. plot(range(1, num_epochs+1), perdas, label='Perda de Treino') ax1. set_xlabel('Iterações') ax1. set_ylabel('Perda') ax1. set_title('Itéracoes vs Perda') ax1. grid() ax2 = ax1. twinx() ax2. plot(range(1, num_epochs+1), acurácias, label='Acurácia de Treino') ax2. set_ylabel('Acurácia') plt. legend() plt. show() ``` <a name="análise-da-acurácia-para-cada-classe-do-mnist-de-moda"></a> ## Análise da Acurácia para Cada Classe do MNIST de Moda ```python class_correto = list(0. por i em range(10)) class_total = list(0. por i em range(10)) apenas para __nógraduate__: para imagens, rótulos em teste_loader: imgs, rótulos = imgs. para(dispositivo), rótulos. para(dispositivo) saidas = rede(imgs) _, predito = torch. max(saídas. data, 1) c = (predito igual rótulos). squeeze() para i em range(10): label = rótulos[i] class_correto[label] += c[i]. item() class_total[label] += 1 p ar com xxx, yyy para __print__: para i em range(10): print('Acurácia de {0}: {1: . 2f} %'. format( classes[i], 100 * class_correto[i]/class_total[i])) ``` Abaixo encontra-se o texto traduzido e formatado em Markdown: # Rede Neural Recurrente RNNs podem ser utilizados para várias aplicações: 1. **Acompanhamento de Imagem** RNNs são utilizados para comentar uma imagem analisando os atividades presentes. 2. **Predição de séries temporais** Um problema de série temporal, como prever os preços de ações de um mês específico, pode ser resolvido usando RNN. 3. **Processamento de Lingua Natural (Mineração de Texto e Análise de Sentimento)** A mineração de texto e análise de sentimento podem ser feitas usando RNN ou Linguagem Natural (NLP). 4. **Tradução de Máquina** Dado um entrada em uma língua, RNNs podem ser utilizados para traduzir a entrada para um idioma diferente como saída. Agora, vamos mexer com a parte programática: ## Importação de Bibliotecas ```markdown # Importar bibliotecas import pandas as pd # Para data frame import numpy as np # Para manipulação numérica import seaborn as sns # Para plotagem from matplotlib import pyplot as plt # Biblioteca de plotagem from wordcloud import WordCloud # Biblioteca para cloud de palavras from nltk. stem import WordNetLemmatizer # Para lemmatizer from nltk. corpus import wordnet as wn from sklearn. model_selection import train_test_split # Para dividir dados from sklearn. feature_extraction. text import TfidfVectorizer # Para converter texto em características TF-IDF from sklearn. metrics import confusion_matrix # Para matriz de confusão from sklearn. linear_model import LogisticRegression # Regressão logística from sklearn. svm import SVC # Classificador de Vetor de Suporte (SVM) from sklearn. naive_bayes import BernoulliNB # Classificador Naivo Bayes Bernoulli import tensorflow as tf # Biblioteca TensorFlow from tensorflow. keras. models import Sequential # Construtor de modelo sequencial from tensorflow. keras. layers import LSTM # Construtor de camadas LSTM from tensorflow. keras. utils import to_categorical # Para codificação em blocos de labels from tensorflow. keras. datasets import imdb # Dados de texto para análise de sentimento ``` O texto restante parece ser código para a realização de análise de sentimento usando RNN, que já está formatado corretamente. Lembra-se que este código requer passos adicionais, como carregar e processar os dados, dividir os dados em treino e teste, tuning de hiperparâmetros, treinar o modelo e finalmente avaliar o desempenho do modelo. Para manter a resposta limpa, skippei algumas partes onde o código já estava formatado ou de forma alinhada com os padrões Markdown. Caso tenha alguma preocupação ou questões específicas ao implementar o código, estarão à minha disposição para ajudar. # URL Pattern Course para Remoção de URLs da WWE Este curso explica o padrão para a remoção de URLs relacionadas à WWE, tanto dos tipos `HTTPS` quanto `HTTP`. Aqui um resumo de como fizemos: 1. **Padrão de URL** - Remoção de URLs em minúsculas - Remoção de usuários (por exemplo, @red) - Remoção de pontuações e palavras de parada 2. **Processamento de Dados** - Processamento de tweets e conversão em formato `Lambda X` - Atualizações de status durante o processamento preliminar - Completamento do processamento preliminar antes de qualquer análise 3. **Análise de Dados** - Criação de nuvens de palavras para funções positivas e não positivas a partir do conjunto de dados - Análise das informações pre-processadas para uma melhor compreensão delas ## Análise de Tweets Negativos ```markdown Primeiro vimos criar nuvens de palavras para palavras negativas ou tweets negativos. ``` ```python plt. figure(figsize=(15, 15)) wordcloud = WordCloud(max_words=2000, height=800, rate=2. 0) wordcloud. generate_from_frequencies(dict(polarity==0)) plt. show() ``` Neste caso podemos ver as palavras mais comuns em nosso conjunto de dados: ``` hoje, eu sou, trabalho, não desejo, precisam muito de ``` ## Análise de Tweets Positivos ```markdown Agora, vamos analisar tweets positivos. ``` ```python plt. figure(figsize=(15, 15)) wordcloud = WordCloud(max_words=2000, height=800, rate=2. 0) wordcloud. generate_from_frequencies(dict(polarity==1)) plt. show() ``` E nesta análise podemos ver as palavras mais comuns em nosso conjunto de dados: ``` amor, boa, LOL, fantástico ``` ## Vectorização e Divisão dos Dados ```markdown Agora vamos converter texto em vectores de frequência e dividir os dados. ``` ```python X = data['tweets']. values y = data['polarity']. values X_treino, X_teste, y_treino, y_teste = train_test_split(X, y, test_size=0. 2, random_state=1) ``` ## Construção e Avaliação do Modelo Agora vamos construir os modelos e avaliá-los em relação a sua precisão tanto no conjunto de treino quanto no conjunto de teste. ```markdown Aqui compararemos o desempenho do regressão logística, SVM linear, floresta aleatória e nosso modelo principal (RNN). ``` ```python from sklearn. linear_model import LogisticRegression from sklearn. svm import SVC from sklearn. ensemble import RandomForestClassifier from keras. models import load_model LR = LogisticRegression() SVM = SVC(kernel='linear') RF = RandomForestClassifier(n_estimators=100, max_depth=50) RNN = load_model('RNN_model. h5') history_LR = LR. fit(X_treino, y_treino) history_SVM = SVM. fit(X_treino, y_treino) history_RF = RF. fit(X_treino, y_treino) history_RNN = RNN. fit(X_treino, y_treino) print("Precisão no conjunto de treino: ") print("Regressão Logística: ", LR. score(X_treino, y_treino)) print("SVM linear: ", SVM. score(X_treino, y_treino)) print("Floresta Aleatória: ", RF. score(X_treino, y_treino)) print("RNN: ", RNN. evaluate(X_treino, y_treino)[1]) print("\nPrecisão no conjunto de teste: ") print("Regressão Logística: ", LR. score(X_teste, y_teste)) print("SVM linear: ", SVM. score(X_teste, y_teste)) print("Floresta Aleatória: ", RF. score(X_teste, y_teste)) print("RNN: ", RNN. evaluate(X_teste, y_teste)[1]) ``` Baseados neste análise preliminar, o modelo RNN mostra um desempenho superior tanto no conjunto de treino quanto no conjunto de teste. Para uma análise mais detalhada e explicações, por favor, veja os respectivos cursos ou tutorials correspondentes. ### Qual é o Primeiro Robô do Mundo Desencanitelo Patenteado? A resposta é Kibo, desenvolvido na Faculdade de Engenharia da Universidade de Toledo Akron em 1979. O Kibo é o primeiro robô humanoide patenteado que foi desenvolvido e construído nos Estados Unidos. --- # Redes Neurais artificiais em Inteligência Artificial | Rede Neural Explainada | Rede Neural | Simplilearn Ideoma: en Hi, everyone, bem-vindo ao Simply Learn! Antes de prosseguir, por favor assine ao canal de YouTube de Simply Learn e ative a notificação para não se perder nas atualizações. O que vai ter em cima para você? Primeiramente, vamos entender o que é uma rede neural, tipos diferentes de rede neural e finalmente aplicações de redes neurais. Agora, antes de começarmos, gostaria de perguntar uma simples questão para todos os entusiastas de inteligência artificial e de redes neurais: Qual é o primeiro e patenteado robô do mundo? Você pode nos informar no comentário. Aqui vem um monster: Não é a Fran. ## O que é uma Rede Neural em Suma? Uma Rede Neural Artificial (ANN) pode ser chamada de sistema de hardware e software que se baseia em como neurônios no cérebro funcionam. Redes neurais artificiais são outro nome para redes neurais. O cérebro tem bilhões de neurônios, eles estão todos interligados. Redes neurais contêm três camadas principais: uma camada de entrada, uma camada de saída, e uma camada oculta. Vamos definir redes neurais. As redes neurais artificiais são uma técnica artificial que imita o cérebro. Em uma rede neural, um neurônio é uma função matemática que coleta e categoriza dados seguindo uma determinada arquitetura. A rede é semelhante às técnicas estatísticas como análise de regressão e contorno. ## Tipos de Redes Neurais Agora, vamos dar um passo adiante e entender os diversos tipos de redes neurais: 1. **Rede Neural de Feedforward** As redes de feedforward são compostas por camadas ocultas e vários neurônios conectados por ligações ocultas. Como não há propagação de trás para frente e apenas as dados são enviados em uma direção, estas são comercializadas como redes de feedforward. 2. **Rede Convolucional Neural (CNN)** Uma Rede Convolucional Neural (CNN) é uma rede neural profunda que aprende diretamente de dados específicos. É utilizada para considerar os padrões, objetos e rostos. As CNNs são mais utilizadas para classificação de imagens. Múltiplas camadas de convolução de CNN são responsáveis pela extração de características significativas da imagem. 3. **Rede Recurrente Neural (RNN)** Quando são necessárias previsões com dados sequenciais, as redes neurais recurrentes (RNN) entram em jogo. Dados de série de sequência podem ser imagens, palavras ou outros tipos de dados. 4. **Multi-nível Perceptron (MLP)** Um multi-nível perceptron (MLP) é uma arquitetura complexa de redes neurais semelhante ao cérebro humano. Um MLP é composto por neurônios interligados que comunicam com um valor atribuído a cada neurônio. Três camadas básicas fazem parte da rede: neurônios conhecidos como perceptrons com várias camadas ocultas e mecanismos de ativação estão ligados a Redes Multi-nível Perceptron. O processo de re-aprendizado conduz-se sob supervisão, e a descoberta das congestões socorre-se geralmente com o uso do gradiente de descerente, que é utilizado para atualizar os pesos em relatórios futuros. ## Aplicações em Mundo Real de Redes Neurais Agora vamos ver aplicações em Mundo Real de Redes Neurais: 1. **Cuidado de Saudável** A oncologia utiliza redes neurais artificiais para treinar algoritmos que podem detectar tecidos malignos a nível microscópico com a mate armação de profissionals médicos de nível. Diferentes doenças raras que podem aparecer fisicamente podem ser detectadas em suas fases iniciais, portanto, a adoção amplia do artificial neural networks na saúde pode aumentar as habilidades diagnósticas dos profissionais de saúde profissionais e no longo prazo a qualidade do cuidado de saúde mundial. 2. **Vendas e Marketing** Baseadas em sua história anterior de navegação, sites e-commerce como Amazon e Flipkart sugerem os destinos enquanto você entra. Semelhante ao como Zomato, Swiggy, etc. , identificam refeições sugeridas de acordo com suas preferências e histórico anteriores de pedidos. 3. **Assistência Pessoal** Talvez tenha ouvido da Siri, Alexa, Cortana, ou outro assistente virtual graças a seus smartphones. Esses assistentes pessoais usam reconhecimento de fala e processamento natural da linguagem. Dois se conversam com os usuários e categorizam respostas em conformidade com suas necessidades. As redes neurais artificiais são empregadas no processamento natural da linguagem para manter muitas dessas funções do assistente pessoal, incluindo a sintaxe da língua, semântica, pronúncia precisa, conversção contínua, e mais. 4. **Mídias Sociais** A função "Pessoas Que Você Pode Conhecer" da Facebook designa ums usuários para solicitar o envio de solicitações de amizade. Os pessoas que podem conhecer são determinados treinando algoritmos de redes neurais que examinam seu perfil, interesses, pessoas já conhecidas, e suas pessoas. A reconhecimento facial é uma usos comum de aprendizagem de máquina nas mídias sociais, pois ajuda a localizar até 100 pontos de referência sobre a imagem de seu rosto e em seguida comparar esses pontos de referência com pontos já existentes na base de dados. ### O que é a Propagação Trasversal em Redes Neurais | Explicação da Propagação Trasversal A resposta para a pergunta é propagação trasversal, e para obter isso, precisamos alterar a saída da camada anterior. No entanto, não podemos alterá-la diretamente; em vez disso, vamos alterar sua camada anterior. ##### Por que precisamos escolher a propagação trasversal? Abaixo estão alguns dos fatores importantes que explicam por que a propagação trasversal é uma opção popular: 1. **Fácil de Implementar**: A propagação trasversal é simples de implementar. 2. **Versatilidade**: A propagação trasversal não requer conhecimento prévio da rede e apenas requer números de entrada como parâmetros para ajustar. 3. **Eficácia**: A propagação trasversal é um método comum que funciona efetivamente em geral. 4. **Nenhum Nota Especial**: Não há necessidade de fazer alguma nota especial sobre as características da função que deve ser ensinada porque é adaptada aos dados de treinamento. O assunto final é **Aplicações da Propagação Trasversal**. Pode ser utilizada em vários campos, incluindo: 1. Reconhecimento de Fala 2. Reconhecimento de Voz 3. Reconhecimento de Assinatura ##### Redes Neurais Além das aplicações acima mencionadas, as redes neurais formam a base da aprendizagem profunda, um subcampo de aprendizagem automática onde os algoritmos são inspirados na estrutura do cérebro humano. As redes neurais aceitam dados, treinam-se para reconhecer padrões nele e predizem saídas para conjuntos de dados semelhantes. ##### Entendendo uma Rede Neural usando Propagação Trasversal Vamos construir uma rede neural que diferencie entre um quadrado, círculo e triângulo. Uma rede neural é composta de camadas de neurônios, onde os neurônios são as unidades de processamento do sistema. 1. **Camada de Entrada**: Esta camada recebe a entrada. 2. **Camadas Ocultas**: Estas camadas realizam a maioria das computações necessárias pelo nosso sistema. 3. **Camada de Saída**: Esta camada predi diz nossa saída final. Cada neurônio em uma camada é conectado a neurônios em camadas seguintes através de canais, e cada canal é atribuído um valor numérico conhecido como peso. Os valores de entrada são multiplicados pelo valor correspondente de peso e sua soma é enviada como entrada para os neurônios da camada oculta. Cada um destes neurônios está associado a um valor numérico conhecido como bias, que é então adicionado à soma de entrada. Este valor é então passado por uma função de ativação conhecida como função de ativação. O resultado da função de ativação determina se o neurônio particular será ativado ou não, e um neurônio ativado transmite dados para os neurônios da camada seguinte através de canais. Este processo é conhecido como propagação de frente para trás. Na camada de saída, o neurônio com o valor mais alto acende e determina a saída. Esta saída é então comparada com a saída real para perceber o erro na previsão. Esta informação é então transmitida para trás pela rede, conhecida como propagação trasversal. Com base nesta informação, os pesos são ajustados, e este ciclo de propagação de frente para trás e propagação trasversal é repetidamente executado até que a rede # Neurão Matemático: Uma Exploração mais Profunda em Um Neurônio e Mais Vamos nos aprofundar mais na matemática de um único neurônio, então exploraremos múltiplos neurônios em uma rede neuronal. ## Um Neurônio Inicialmente, examinaremos um neurônio, representado simbolicamente como `a`, semelhante ao neurônio anterior (que chamaremos de `f`). Aqui, utilizaremos a letra `g` em vez de `f` para a função de ativação. ```markdown Temos todos estes θ's multiplicados pelos x's (os seus respectivos inputs). Se escrevenos como w's vezes todos os x's, e tomarmos a somação e passarmos por uma função g, obtemos a nossa função de ativação. ``` Suponha que quisermos escrever esta função usando álgebra linear através de uma matriz. Para os pesos (w's), poderemos representá-los como uma matriz `W`, e os inputs, `x`, como um vetor. ```markdown W x | w₁ w₂ . . . wₖ | | x₁ x₂ | | | | . . . | = | . . . | | wₖ₁ wₖ₂ . . . wₘₘ | | xₖ₁ xₖ₂ | Adicionamos um termo de perna para cada neurônio. Isso nos dá um vetor de entrada biasado, `xb = [1, x₁, x₂, . . . , xₖ]`. Em seguida, com a função de ativação, `g`, obtemos: f(Wx + b) = a ``` ## Múltiplos Neurônios Para múltiplos neurônios (que chamaremos de `a₁`, `a₂`, e `a₃`), precisaremos de mais pesos e inputs. ```markdown Inicialmente, tinhaos quatro entradas e uma saída para o único neurônio. Agora, com três neurônios, temos quatro vezes três, ou 12 pesos. ``` Representamos os pesos como uma matriz `W` (`w₁₁`, `w₁₂`, `w₁₃`, . . . , `wₘₘₒ`), os inputs como uma matriz `X` (os inputs de `a₁`, `a₂`, e `a₃`) e um termo de perna para cada neurônio (`b₁`, `b₂`, e `b₃`). ```markdown W X X X Camada |-----| | w₁₁ w₁₂ . . . w₁ₖ | | x₁₁ x₁₂ | | x₂₁ x₂₂ | | x₃₁ x₃₂ | | | | . . . | = | . . . | | . . . | --- --- --- Camada |-----| | wₘₘ₁ wₘₘ₂ . . . wₘₘₒ | | xₘₘ₁ xₘₘ₂ | | xₘₘ₁ xₘₘ₂ | | xₘₘ₁ xₘₘ₂ Com a função de ativação, `g`, obtemos: fa = g(WX + b) ``` ## Redes Neurais Profundas Uma rede neuronal profunda possui mais de uma camada. Com múltiplas camadas, se torna mais complexa, e as matemáticas envolvidas se tornarão cada vez mais complicadas. O número de sinapses (axons, dendrites, e a sinapses entre si) aumentará com mais camadas e neurônios. ```markdown Temos quatro neurônios (quatro neurônios de entrada, três neurônios ocultos, e um neurônio de saída) nossa rede neuronal de duas camadas. Se contarmos as fletchas, teremos 12 (o número original de pesos/sinapses para um único neurônio) + 3 (os pesos adicionais para cada dos três neurônios ocultos) = 15 sinapses diferentes. ``` ## Redes Maiores e Aplicações Com redes maiores, é possível obter resultados muito mais interessantes. Aqui está um exemplo de rede mais larga: ```markdown Esta é uma rede neuronal de duas camadas com a camada de entrada, a camada oculta (com, por exemplo, 16 neurônios) e a camada de saida (com 10 neurônios). A aplicação para tais redshift poderia ser reconhecimento de dígitos à mão usando o dataset MNIST. A camada de entrada possui uma matriz 784 x 1, onde cada pixel na imagem do dígito à mão escrita é representado por 0 ou 1, dependendo se o pixel está aceso ou não. A camada de saída contém 10 neurônios, que correspondem aos dígitos de 0 a 9. O número de sinapses (conexões entre neurônios) será 784 × 16 + 16 × 10 = 12, 320. O número total de neurônios necessários para este aplicativo é 16 (a camada oculta) + 10 (a camada de saída) = 26. ``` # Rede Neural de Convolução: Redes Neurais Convolucionais (CNNs) Redes Neurais Convolucionais (CNNs) são um tipo de rede neural que se tornaram essenciais para a reconhecimento de imagens. ## Visão Geral CNNs apresentam uma estrutura diferente das redes neurais de feedforward comuns em termos de neurônios e funções de ativação. Eles são particularmente eficazes para o reconhecimento de imagens, não apenas números escritos à mão, mas imagens mais complexas, como rostos, devido à sua capacidade de identificar padrões em grandes quantidades de dados. ! [Estrutura de CNN](https://www.tensorflow.org/tutorials/keras/conv_1d) Uma CNN consiste em várias camadas, incluindo camadas de convolução, ativação (como ReLU) e camadas de pooling, cada uma executando cálculos específicos para extrair e identificar características dentro da imagem de entrada. As camadas são colocadas uma após a outra e a saída fornece uma predição baseada nos dados de imagem. ## Estrutura de uma CNN ### Estrutura Básica A estrutura básica de uma CNN se assemelha à mostrada aqui abaixo. A camada de entrada transmite informações para a camada de saída, e a saída fornece uma predição, como identificar o objeto na imagem. Para alcançar mais precisão e entendimento, podemos adicionar mais camadas e ajustar sua configuração. ```markdown Layer de Entrada | Layers de Convolução -> Layers ReLU -> Layers de Pooling ``` ### Camada de Convolução Uma camada de convolução utilize um filtro de matriz para detectar padrões na imagem de entrada. A operação de convolução toma a data e a verte para detectar novos padrões. Pode ser seguida por uma função de ativação, como ReLU ou max pooling. ### Layers ReLU O Rectified Linear Unit (ReLU) é uma função de ativação usada para introduzir não linearidade na rede neural. ### Camada de Pooling Uma camada de pooling reduz as dimensões espaciais dos dados de entrada enquanto manter os dados essenciais. ### Camadas Adicionais A rede neural profunda reconhece objetos em imagens com a ajuda dessas camadas, começando pela camada de entrada que aceita pixeles de imagem no formato de arrays, passando por camadas escondidas que realizam a extração de feature, e terminando com a camada de saída que identifica o objeto em imagem. **Pontos importantes a aprender** * Compreender a estrutura e as camadas de uma rede neural convolucional (CNN) * Visão geral das camadas de convolução, ReLU e pooling em uma CNN * O papel de cada camada no reconhecimento de imagens em uma CNN **Implementação de Caso de Uso** Para implementar uma CNN para reconhecimento de imagens, podemos começar pela aprendizagem sobre o pioneiro da rede neural convolucional, Jan Lecun, seguida pelo entendimento dos fundamentos básicos de como uma CNN reconhece imagens. Para uma experiência prática, você pode trabalhar em implementar uma CNN usando bibliotecas como TensorFlow ou Keras. Fontes: - [TensorFlow - Uma introdução de seis minutos à Rede Neural Convolucional (CNNs)](https://www.tensorflow.org/tutorials/keras/conv_1d) - [Aprendendo a Rede Neural Convolucional (CNNs) com Código](https://www.datacamp.com/community/tutorials/deep-learning-scratch-convolutional-neural-networks) # Redes Neurais Convolucionais: uma visão geral ## Camadas em Redes Neurais Convolucionais Esta seção fornece uma visão geral das diferentes camadas em uma Rede Neuronal Convolucional (RNC), especificamente focando no papel de uma RNC na processamento de imagens. ### Camada de Convolução A camada de convolução é o aspecto central da processamento de imagens nas RNCs. Consiste em realizar uma operação de convolução na imagem de entrada. Devido à sua importância crucial no processamento de imagens, camadas de convolução são um componente fundamental de RNCs. ### Camada de ReLU (Unidade Linear Realificada) A camada de ReLU é ativada pelo que está por atrás dela, o que determina como as celulases acendem. O principal propósito da camada de ReLU é introduzir uma não-linearidade na rede. A camada de ReLU funciona muito bem para processar quantidades pequenas de dados em cada imagem. ### Camada de agrupamento A camada de agrupamento é usada para reduzir as dimensões espaciais da representação foi tomando o valor máximo ou média de uma região do mapa de características. O objetivo principal da camada de agrupamento é reduzir os requisitos computacionais, reduzindo o tamanho dos mapas de características e tornando a rede mais eficiente computacionalmente. ### Camada camada completamente conectada Finalmente, a camada completamente conectada é a camada de saída da RNC. Ela computa a probabilidade de cada classe para uma dada imagem de entrada. ### Exemplo Considere a seguinte imagem de 5x5, onde os valores dos pixels são apenas 0 e 1: ``` 0 0 0 0 0 0 1 1 1 0 0 1 1 1 0 0 0 1 1 0 0 0 0 0 0 ``` No contexto de uma RNC: 1. Uma matriz de filtro, derivada durante o treinamento do modelo, é deslizada sobre a imagem. 2. A soma produto dos elementos entre a matriz de filtro e uma parcela da imagem é calculado para detectar padrões. 3. Múltiplos filtros, projetados para olhar para diferentes aspectos, são aplicados simultaneamente à imagem. 4. O resultado é um mapa de característica com apenas as características ativadas que estão sendo examinadas, e como eles pesam em relação aos filtros. ## Estrutura de uma Rede Neuronal Convolucional 1. Camada de Entrada: Uma imagem de entrada é fornecida para a RNC. 2. Camadas de Convolução: A imagem de entrada é convolvida com vários filtros, que são projetados para torcer e alterar os dados. A multiplicação de matrizes gerencia a criação de múltiplas camadas de convolução. 3. Camada de ReLU: Múltiplas camadas de funções de ativação ReLU são aplicadas às várias camadas de convolução. 4. Camadas de agrupamento: Múltiplas camadas de agrupamento são usadas para agrupar os dados, reduzindo seus dimensões ou achatando-os. 5. Achatamento: Todas as matrizes bidimensionais resultantes das camadas de agrupamento de mapas de características são transformadas em um único vetor linear contínuo longo. 6. Camada camada completamente conectada: O vetor achatado da camada de agrupamento é depois alimentado como entrada para a camada completamente conectada para classificar a imagem. # Rede Neural de Convolução: Reconhecimento de Ave Este documento descreve o processo de implementar uma Rede Neural de Convolução (CNN) para reconhecimento de aves a partir do conjunto de dados CIFAR-10. ## Visão Geral Uma CNN é um modelo de aprendizagem profunda particularmente indicado para tarefas de processamento de imagens. Ele utiliza uma série de camadas convolutivas, ativações ReLU, camadas de pooling e camadas totalmente conectadas para classificar imagens. Neste caso, utilizaremos o conjunto de dados CIFAR-10 do Instituto Canadien de Pesquisa avançada para classificação de imagens em 10 categorias. ### Imagem de Entrada A imagem de entrada é primeiramente girada e multiplicada por filtros, com cada filtro multiplicado por uma matriz para criar a camada de convolução. Utilizaremos várias camadas de convolução devido à arquitetura estruturada que cria várias camadas a partir de diferentes filtros. ### Camada de Convolução A camada de convolução consiste de várias camadas devido à arquitetura estruturada, que faz a combinação de filtros e matrizes para criar a camada de convolução final. ``` Nossas camadas de convolução: - Multiplicando filtros por matrizes - Criando várias camadas com filtros diferentes ``` ### Ativação ReLU Após a camada de convolução, o dado passa por uma ativação ReLU para criar a camada de pooling. ``` Função de ativação: - ReLU ``` ### Camada de Pooling A camada de pooling é responsável pela busca da máxima valor que provém da convolução, aplanando a camada e mandando a camada aplanada para a camada de camada completamente conectada. ``` Operações de Pooling: - Buscar a máxima valor no pooling - Aplanando a camada ``` ### Camada Totalmente Conectada A camada totalmente conectada neural recebe o dado aplanado e passa para a camada de saida. ``` Rede Neural totalmente conectada: - Recebe o dado aplanado - Lidera para a camada de saída ``` ### Camada de Saída A camada de saida contém a saída final, que é a classificação da imagem como uma de cada uma das 10 categorias. ``` Camada de saída: - Camada de saida final para classificação ``` ## Caso de Uso: Conjunto de Dados CIFAR-10 No nosso caso de implementação, utilizaremos o conjunto de dados CIFAR-10 do Instituto Canadien de Pesquisa avançada para classificar imagens em 10 categorias. Note que o conjunto de dados não especifica explicitamente o tipo de ave, mas ajuda com a classificação em categorias como um navio, sapo, veado, pássaro, avião, carro, gato, cão, cavalo e caminhão. ## Passo a Passo pelo Código Para auxiliar a compreensão do processo, vamos dar uma descrição passo a passo do código. Isto pode fazer com que seja mais fácil, mesmo com várias etapas e subetapas envolvidas. ### Importando Libraries A primeira etapa é importantíssima importar as bibliotecas necessárias, incluindo Matplotlib e NumPy. ```python import matplotlib. pyplot as plt import numpy as np ``` ### Preparação dos Dados Quando os dados são carregados, vamos reformatá-los Este Markdown deu-se transforma no conjunto de markdown em outra linguagengue usado em Portugal através: Um método básico consiste traduzir, usando comandos likeGoogle Translates e por software traduttore de on-line en si. Quanto ao `python` se tem a maior flexbiliblídade. Primeiramente usámos libraries en `BeautifulSoap4 (<https://beautysoup.python.org>/`_) a python-fluent `Portuguese for BeautifulSoupy`([http://hplgit1.fb.com/Hyperscar/h/b-PyPortugal/) e os packages natiu de `string`, `argparse`, se você conseguir remover algunas funkíções após tradunção que nâo pudesse consertar-se correstamente com recursos como likeGoogle Transalates ou lenguages extrados natüas como inglês , españhol-Brasiel etc. `](https: Note that I just use this Google translate function inside python. Keep in mind any Google service such as translate usually do have different performance level comparing with real portuguese linguage and dialect (especially comparing the one usually found in Mozambique that you used (europeino)), also a service sucha of that, only help for literal translate of short content like: `This dataset consist of labels of animals class (0 (chicken eggs) or negative labels). Only two class as no images belong to neither a negative nor labeled image` This service cannot have context awareness between your sentence where this function must handle different usage. Also since google does make translation as quick and accurate using translation of entire words/nouns when used, may seem awkward. On contrary this libraries of Python offers greater flexivilty when adapting such translate task within any typeof projects --- Preparação `Data` **[** Preparação Do `Dado**`]] ================= ######## V ~~Stacado `Numero ~~ Pêlos ~~D~~array com Stack ~~**de Imgenagens ***De** Auto Entrenhaemnte`) Exemplificasemo treina a lispa`ds de en`quntes que nos estamos fazendo sem ele`ser filios `; estas batch`ds não existem dj na eira, as estas carregados o enderecu na lhei propres dos `**p~~unetrs datadbata ~~Bucak``ses**há. ** De nosso método `e a duda seria preparado na~~ stackado estes noNum~~array ao~ numpy apurantaea` ``` Python # Faremos ~~A ccarregament ~~l'sd aosso mesmo treino de forma~ data pr es~**seu, de enxercicio no array ao meu **Tutnuméro pessoul `(as **batcha~tr_dba)***` (istoé apagament'a a mesma. ) } P(~car # Preencha-ls no nuampyy **arcowr de tu_tmd a_selfs d traina ~~o todosos exerciciod datatatabases*~~. ) ``'s`-trab__o, (jantat o sessor. O treinamos tds ~o nps imagemso`no Nun`emarr y ) ```Python~~] **########`D **~~Nun~ Training ~`Cumultal~o número Fomos à pegar a a carcim `~ do_ self Treina-menotos ~; *` número toal-ls do trainning auto t~*p-mns)~~*. ~~' s- ------------------------------- -------- }~~. 168: print**(*n('_t, *`length ** de \_\_ 'S) \__trainingnimages__) *__ training\_l `enhg, tlen '* __~~lengtha __l, n('numbre ~ o **truening \caraem**ns ) **length**) ~~ `1- __n((e1a2__gamnesnse[ i __t 'numbers _ts ) , len(*datalst [~' ) **e)**-t ``` `~= enume ```) `s en ```l o n[, _ ~ **a _a 0 ']-** ```\i `se ~~, pai ao self imagenc **[l a # Aprenda a Criar uma Rede Neuronal Confusa com Redes Neurais Convolucionais (CNN) Neste tutorial, será demonstrado como criar uma rede neuronal confusa (CNN) para o processamento de imagens utilizando o Python e a biblioteca TensorFlow. Vamos começar criando uma camada de convolução 2D e se familiarizar com a funcionalidade de pooling. --- ## Introdução Neste tutorial, será demonstrado como criar uma rede neuronal confusa (CNN) para o processamento de imagens utilizando o Python e a biblioteca TensorFlow. Vamos começar criando uma camada de convolução 2D e se familiarizar com a funcionalidade de pooling. --- ### Convolução 2D Uma camada de convolução utiliza filtros para processar uma imagem. O filtro se move sobre a imagem e avalia as sub-regiões (boxes) da imagem. O processo repete-se este movimento com o passo definido até que a imagem seja completamente processada. ```markdown # Convolução 2D Uma camada de convolução utiliza filtros para processar uma imagem. O filtro se move sobre a imagem e avalia as sub-regiões (boxes) da imagem. O processo repete-se este movimento com o passo definido até que a imagem seja completamente processada. ## Filters Os filtros são importantes na camada de convolução. Se um filtro for alterado (aumentar o número, tamanho, etc), alterará a altura e largura da saída da camada de convolução. ## Kernels Nosso exemplo usará 32 kernels de 3x3, o que reduz a altura e largura da entrada inicial para 1/9. ``` --- ### Pooling O pooling é um passo opcional após a camada de convolução. Reduz as dimensões do mapa de convolução, retirando a resolução temporal de uma imagem. Usaremos o pooling máximo. ```markdown # Pooling O pooling é um passo opcional após a camada de convolução. Reduz as dimensões do mapa de convolução, retirando a resolução temporal de uma imagem. Usaremos o pooling máximo. ## Pooling Maximo Para o pooling máximo, encontramos a maior entrada na janela e utilizamos o valor maior. Isso ajuda a manter-lo concentrado em uma posição específica, ou seja, cada posição possui como um melhor resultado possível. ## Pooling Média Muitas vezes não é necessário utilizarmos uma pooling máxima. A média de um pooling também pode funcionar adequadamente com bons resultados. Especifique configurações de teste para seu pooling de acordo com a necessidade do seu problema. ``` --- ### Full Connected Layer A camada de conexão completa (FC) tem três camadas de processamento. 1. *Flatten*: A coleção de sub-matrizes que possuem o tamanho correto para o envio para a camada de conexão completa (FC) única. 2. *FC Única*: A camada de conexão completa é composta por uma camada de conesionamento dados e uma camada regular. Geralmente, a camada regular é ativada por uma função linear. 3. *Droput*: Evita sobre-aprendizagem. A camada dropout é uDAP (Dropout dice Agating Probability) com uma probabilidade diferente para cada nó. 4. *Softmax*: Uma camada especial usada para probabilidades, utilizada como a última camada da rede neuronal. --- ## Conclusão É importante compreender a arquitetura de uma CNN sempre que se trabalhar com imagens. Explore e use diferentes configurações para encontrar as que melhor se adaptam ao seu problema. --- Ligue-se para saber mais sobre deep learning. ```markdown [Neste vídeo de SIMPLY LEARN](#), você pode aprender a construir sua própria rede neuronal confusa. Com nossa plataforma gratuita de aprendizado, você ganhará um acesso de 1000 horas de conteúdo de deep learning pago e saiba mais sobre 300 céus exigidos para o mercado de trabalho! ``` # Criando um modelo do TensorFlow Este tutorial vai guiar você pelas etapas de criar um modelo do TensorFlow. ## Introdução Vamos: 1. Criar uma variável para inicializar todas as variáveis globais do TensorFlow 2. Inicializar as variáveis e preparar os dados para treinamento 3. Treinar nossos dados usando o modelo do TensorFlow ## Configuração Primeiro, vamos criar uma sessão do TensorFlow: ``` com tf. Session() as s: # Inicializar variáveis globais tf. global_variables_initializer(). run() para i em range(500): batch = ch. next_batch # Treinar o modelo perda, acurácia = train(batch) se i % 100 == 0: print("Passo", i, "Acurácia formatada: ", acurácia) ``` ### Inicialização Criamos uma `tf. Session()` e então inicializamos as nossas variáveis globais usando `tf. global_variables_initializer(). run()`. Para os dados, dividimos e agrupamos em 500 pontos. ### Treinamento Dentro do loop de treinamento, treinamos o nosso modelo usando o dicionário de alimentação e o nosso otimizador treinado (não mostrado aqui). Para cada 100 passos, impresso a perda atual e a acurácia. ## Interpretação dos Resultados Neste caso, uma acurácia de 1 é a perfeição, mas é quase impossível alcançá-la na prática. Em vez disso, é melhor procurar uma acurácia próxima a 1 como um bom sinal de que o modelo está aprendendo bem. A acurácia varia levemente durante o processo de treinamento, então pode ver como ela muda com cada passo. ## Conclusão Este tutorial forneceu uma visão geral de como criar um modelo do TensorFlow, incluindo a inicialização de variáveis globais, a preparação dos dados para treinamento e o treinamento do modelo. ### Profundidade na Rede Neural Recorrente (RNNs) Nesta seção, vamos: 1. Entender o que é uma rede neural e os tipos de redes neurais populares 2. Aprender sobre redes neurais recorrentes (RNNs) e seus casos de uso 3. Implementar uma rede LSTM (Long Short-Term Memory) usando o TensorFlow para um caso específico #### Introdução às Redes Neurais Recorrentes As Redes Neurais Recorrentes (RNNs) são um tipo de rede neural comumente usada para tarefas que exigem uma compreensão dos dados sequenciais, tais como modelar padrões em séries temporais ou texto. Por exemplo: - O recurso "auto-completar" da Google: Prediz o resto das palavras que o usuário está digitando - Sugerir a comida melhor a se comer em uma cidade específica Essas redes podem ser poderosas ferramentas que nos salvam significativos quantidades de tempo e são amplamente usadas em inúmeras aplicações. #### Redes Neurais na Aprendizado Profundo As redes neurais consistem de várias camadas interligadas umas às outras, funcionando como a estrutura e as funções de um cérebro humano. Eles aprendem de grandes volumes de dados usando complexos algoritmos para treinar uma rede neural. Pode avaliar uma inteligência artificial comparando suas funcções às dos humanos. #### Tipos de Redes Neurais Populares Aqui estão alguns tipos de redes neurais populares: - Rede linear de Neurônios: Usada em problemas gerais de regressão e classificação - Convolução Neural Network: Usada em reconhecimento de imagem - Rede profunda Neural: Usada em modelagem acústica - Rede Neural Recorrente: Usada em reconhecimento de fala Cada um desses modelos pode ser combinado e adaptado para diferentes tarefas de modelagem, de acordo com as necessidades específicas. # Redição Rede Neural vs Rede Recurrente Neural ## Rede Neural de Avanço (FNN) ### Fluxo de Informação Em uma **Rede Neural de Avanço (FNN)**, o fluxo de informação ocorre apenas em direção para adiante, de nós de entrada através de camadas ocultas (se existirem) até os nós de saída. Não há ciclos ou laços na rede, como mostrado a seguir: ``` Camada de Entrada -> Camadas Ocultas (opcionais) -> Camada de Saída ``` #### Versão Simplificada ``` Entrada (x) -> Camadas Ocultas -> Saída (y) ``` Ocorre que as previsões são baseadas no entrada atual (x) e não possui memória sobre o escopo passado ou futuro num **Rede Neural de Avanço**. ### Problemas em Rede Neural de Avanço Um de maiores problemas em uma **Rede Neural de Avanço** é sua incapacidade de lidar com dados sequenciais. Ele só considera a entrada atual sem considerar entradas passadas ou futuras que possam afetar a saída. Por exemplo, se você tem uma série de coisas, e o que aconteceu três pontos atrás afeta a saída atual, uma **Rede Neural de Avanço** não taking into account this information. ## Rede Recurrente Neural (RNN) ### Solução para Rede Neural de Avanço Para lidar com este problema, oferecemos a Rede Recurrente Neural (RNN). Em uma RNN, as camadas ocultas memorizam o que acontece e alimentam a informação para a próxima. Isso permite que a RNN possa lidar com dados sequenciais, pois considera a entrada atual e também as entradas anteriormente recebidas: ``` Entrada (x) -> Camadas Ocultas (h) -> Saída (y) ``` Em meio ao diagrama, há um valor `c` que representa o processo de memorização do que acontece nas camadas ocultas e as camadas ocultas como produzem dados entram na próxima. ### Aplicações da RNN - **Captação de Imagens**: A RNN é usada para fazer a captação de uma imagem através de análise das atividades presentes nele. - **Predição de Série Temporal**: A RNN pode ser utilizada para resolver qualquer problema de série temporal, como prever os preços das ações em um mês determinado. - **Processamento de Linguagem Natural (NLP)**: minerado de texto e análise de sentimentos podem ser executadas usando RNN para processamento de linguagem natural. - **Tradução Máquina**: Dado uma entrada em uma língua, a RNN pode ser usada para traduzir a entrada em outra língua como saída. ## Problemas de Gradiente na RNN Quando treina uma RNN, o desce pode ser muito pequeno ou muito grande, o que faz banko complicado. Esses problemas são conhecidos como o problema doGradiente vanish e o problema doGradiente explosão, respectivemente. ### Problema doGradiente Vanish O problema doGradiente vanish ocorre quando não é fornecido suficiente informação, resultando em perda de informação ao longo do tempo. Isso pode causar problemas ao treinar a rede, e você começa a perder partes da sequência, ou não segue inteiramente a lógica de o que está sendo trabalhado. ### Problema doGradiente Explosão Por outro lado, o problema doGradiente explosão ocorre quando o desce tendencia a crescer exponencialmente, em vez de decair. Esse problema é mais grave e pode causar péssima acurácia, baixo desempenho, e tempo de teste longo, e pode bloquear o seu computador e forçar um erro de memória quando testar um modelo. ### Soluções para os problemas de Gradiente Existem várias abordagens para abordar os problemas de gradiente: 1. **Inicialização de Identidade**: Encontre uma forma de minimizar as identidades que entram, focando somente nas informações importantes. 2. **Truncated Backpropagation Through Time (TBPTT)**: Trumque a propagação de gradientes, reduzindo o tamanho de um conjunto específico de camadas. 3. **Cortação do Gradiente**: Corta o gradiente para acompanhar o modelo de treinos em larga. Para o problema doGradiente vanish, podemos olhar para a inicialização das pesos, a eleição da função de ativação certa, e a memória longo-curto (LSTM). Para o problema doGradiente explosão, podemos focar na inicialização das pesos e a eleição da função de ativação apropriada. A memória longo-curto (LSTM) também é uma boa solução para esse problema. # Redes de Memória de Termos: LSTMs e dependências em longo prazo As Redes de Memória de Termos (Term Memory Networks), também conhecidas como Redes Long Short-Term Memory (LSTMs), são um tipo de rede neuronal recurrente que são capazes de aprender dependências em longo prazo e manter informação durante longos períodos de tempo. Isso é o seu comportamento padrão. Todas as redes neuronais recurrentes possuem uma estrutura com forma de cadeia, com um módulo repetitivo de conexões de rede neuronal. Nesta rede neuronal padrão, este módulo repetitivo é simples, normalmente composto por apenas uma camada hiperbólica tangente (tanh). LSTMs, no entanto, possuem uma estrutura diferente. Eles também possuem uma estrutura com forma de cadeia, mas o módulo repetitivo possui quatro camadas interagentes. Estas camadas se comunicam de uma maneira muito especial, o que faz as LSTMs capazes de aprender dependências em longo prazo e lidar com informação sequencial longa: ```markdown Nas LSTMs, temos três etapas de processamento: 1. Porta de esquecimento: A primeira etapa é decidir qual informação esquecer do passo anterior. Isso é útil quando se trata de informações irrelevantes para a situação atual. A porta de esquecimento é decidida por uma função de sigmoide, que vista a estado anterior `h(t-1)` e o input atual `x(t)`, computa a função: `f(t) = sigmoid(W_f * x(t) + U_f * h(t-1) + b_f)` 2. Porta de entrada: A segunda etapa é decidir qual informação adicionar ao estado atual. Uma função de sigmoide e uma função hiperbólica tangente são utilizadas nesta etapa: `i(t) = sigmoid(W_i * x(t) + U_i * h(t-1) + b_i)` `c(t) = tanh(W_c * x(t) + U_c * h(t-1) + b_c)` 3. Porta de saída: A terceira etapa é decidir qual informação sair. Isso é decidido por outra função de sigmoide: `o(t) = sigmoid(W_o * x(t) + U_o * h(t-1) + b_o)` `h(t) = o(t) * tanh(c(t))` ``` Agora vamos ver que isto se parece: Etapa 1: Decidir o que esquecer ---------------------- A porta de esquecimento decide quanto da informação do passado deve ser mantida. Isso é feito através de uma função de sigmoide. A função leva o estado anterior `h(t-1)` e o input atual `x(t)` para computar a porta de esquecimento: `f(t) = sigmoid(W_f * h(t-1) + x(t) + b_f)` Onde `W_f`, `U_f`, `b_f` são os pesos e Londres parada, para a porta de esquecimento. Etapa 2: Decidir o que adicionar ----------------------------- A porta de entrada decide quanto de informação nova adicionar ao estado atual. Duas funções de sigmoide e uma função hiperbólica tangente são utilizadas nesta etapa: 1. `i(t) = sigmoid(W_i * x(t) + U_i * h(t-1) + b_i)` 2. `c(t) = tanh(W_c * x(t) + U_c * h(t-1) + b_c)` Onde `W_i`, `U_i`, `b_i` são os pesos e Londres parada, para a porta de entrada, e `W_c`, `U_c`, `b_c` são os pesos e Londres parada, para o estado da célula. Etapa 3: Decidir o que sair ------------------------- A porta de saída decide qual informação sair. Isso é feito através de outra função de sigmoide: `o(t) = sigmoid(W_o * x(t) + U_o * h(t-1) + b_o)` `h(t) = o(t) * tanh(c(t))` Onde `W_o`, `U_o`, `b_o` são os pesos e Londres parada, para a porta de saída. Estas etapas repetem-se para cada passo na sequência. Isso ajuda LSTMs a lembrar de informações em longo prazo e lidar com informação sequencial longa. **Dependências em longo prazo** No previsionamento de texto, uma das mais comuns das dificuldades é lidar com dependências em longo prazo. Por exemplo, se tentarmos prever a última palavra no texto "Os nuvens estão nos e dizis que o céu", não precisamos de mais contexto, pois é bastante claro que a última palavra será "céu". No entanto, se tentarmos prever a última palavra no texto "Estou tendo estado em Portugal por último 10 anos, posso falar português fluentemente", precisamos do contexto de "Portugal" para prever a última palavra, pois a palavra em que prevemos dependerá dos poucos últimos termos no contexto. Nestes casos, as LSTMs pode nos ajudar a resolver o problema pois são capazes de aprender dependências em longo prazo e lidar com informações por longos períodos de tempo. **Uso de caso: Predição de preços de ações** As LSTMs também podem ser usadas para previsionamento de preços de ações, como demonstrado no seguinte caso de estudo. Nesta exemplo, vamos usar uma rede LSTM para prever os preços de 2017, com base nos preços de ação entre 2012 e 2016. Este é um conjunto de dados limitado, pois a Bolsa de Valores de Nova York gera aproximadamente 3 trilhões de dados por dia, mas ao focar em algumas informações básicas de fundamental, podemos ainda fazer algumas previsões: ```markdown Para prever os preços de 2017, seguimos estes passos: 1. Importar as bibliotecas e os dados 2. Preprocessar os dados 3. Construir e treinar o modelo LSTM 4. Usar o modelo treinado para prever os preços de 2017 ``` Neste caso de estudo, vamos usar Anaconda, o Notebook Jupyter, e o modelo LSTM treinado para prever os preços de ação. Se você gostaria de seguir naqurus, certifique-se de ter estas ferramentas instaladas, assim como quaisquer pacotes adicionais necessários para aprendizado de máquina. **Obs. ** Por favor, note que esta é uma explicação simplificada das LSTMs e de sua utilização no previsionamento de preços de ação. Para fazer previsões precisas e úteis, você precisaria coletar e preprocessar uma quantidade substancial de dados de preços de ação e realizar um análise mais extenso usando técnicas de aprendizado de máquina. Referências: 1. "Entendendo LSTMs" por Andrew Ng, Coursera 2. "Deep learning" por Ian Goodfellow, Yoshua Bengio, e Aaron Courville, MIT Press, 2016 # RNN Stock: Começando com o TensorFlow usando Jupyter Notebook (português de Portugal) Você pode utilizar Anaconda ou Jupyter (ou qualquer outro IDE de Python que preferir). Gosto particularmente do Jupyter pois maintaining todas minhas trabalhos separados. Neste computador, specificamente instalei o ambiente do Anaconda para cross desde que vamos estar trabalhando com cross sob Tensorflow. ## Home Para voltar para casa, subi até _"Aplicações"_ e isso é o ambiente que carreguei aqui. Em seguida, clicamos em _"Executar Jupyter Notebook"_. Já configurei uma grande quantidade de coisas no Jupyter Notebook para que estivemos prontos ao ir. ### Preparação de Dados A primeira coisa que vamos fazer é a nossa preparação de dados. A maior parte de pré-processamento é envolvida, principalmente com o cross, pois ele possui coisas pré-instaladas. Isso pode ser bastante útil. Cross requer alguns passos que são frequentemente encontrados em um setup de keras, portanto, vamos olhar para isso para ver o que aparece no nosso código enquanto passamos pelo processo. ### Avaliação A próxima peça mais importante é avaliar. Se você trabalha com acionistas ou turmas, etc. , avaliação é o próximo passo crítico. Aqui tem um resumo geral dos passos: 1. Carregar os dados 2. Preparar os dados 3. Criar e treinar a rede neural 4. Avaliar a rede ## Carregando Dados Vamos iniciar carregando nosso conjunto de dados: ```python import pandas as pd # A tabela original foi definida como: home/ubuntu/downloads/google_stock_price_train. csv # Alterei isso nesse caso porque estou executando o código na mesma localização # que este arquivo de python e não preciso da caminho completo. data_set_train = pd. read_csv('google_stock_price_train. csv') ``` Em seguida, vamos pegar valores específicos: ```python # Nesseste caso, usamos pandas, portanto, pandas parece uma planilha # neste caso, estamos utilizando iloc, que pega localizações específicas # O primeiro valor vai mostrar que estamos puxando todos os registros e as dados # O segundo valor, estamos apenas olhando colunas uma e duas training_set = data_set_train. iloc[: , [0, 1]] ``` Vamos olhar para o arquivo original: ```python # Aqui vamos abrir isso em um editor básico de palavras e para olhar para ele # Vemos que este é um arquivo separado por vírgulas # Tem uma data, aberta, alta, baixa, fechada, volume ``` ## Preparando Dados Aqui vamos escalonar nossos dados usando `sklearn. preprocessing. MinMaxScaler`: ```python from sklearn. preprocessing import MinMaxScaler escalonador = MinMaxScaler() # Usaremos escalonado_treino nos nossos conjuntos de treino quando testarmos nosso modelo escalonador. fit(treino) escalonado_treino = escalonador. transform(treino) ``` ## Criando e Treinando a Rede Neural TBD ## Avaliando a Rede TBD # Regressor LSTM com Regularização de Dropout Este guia explica como utilizar uma camada `LSTM` combinada com regularização de ruído em uma rede neural para previsões de regressão. O `LSTM` (Long Short Term Memory) é uma das redes neurais recurrentes mais utilizadas e eficazes para processar dados séries temporais. ## Introdução Ao longo desta análise, você aprenderá a: - Utilizar o modelo sequencial de ages em LSTM - Aplicar o Módulo Dropout regularizaça para evitar sobreaquelquamento de rede - Treinamento e visualização de resultados ## Instalando as dependências Para iniciar, verifique se você tem a biblioteca adjacente de Python instalada para a sua versão. Você pode obter instruções de instalação em [Aguas Livres](https://github.com/LSTM-Course/data) . ```bash pip install ages ``` ## Dados de exemplo Neste tutorial, usaremos o mesmo conjunto de dados utilizado para a análise do modelo de regressão. Se você não tiver os dados disponíveis, você pode seguir estas etapas para obter e pré-processá-los. 1. Baixe o conjunto de dados [Google Price Data](https://archive.ics.uci.edu/ml/machine-learning-databases/stock-portfolio/Stock_Price_Data_for_TP_2.xls) 2. Extraia o arquivo CSV utilizando o formato de opção do Windows 3. Altere o caminho para o arquivo CSV `google. csv` para o caminho do arquivo na revista. ## Configuração do ambiente No seu notebook Jupyter ou ambiente de trabalho, conecte-se à biblioteca CaS e importe o módulo `Sequential`. ```python import ages from ages. keras. models import Sequential ``` ## Entrada e pré-processamento dos dados ```python # Caminho para o arquivo CSV de dados de preço data_file = "google. csv" # Importe a biblioteca Pandas para processamento de dados import pandas as pd # Ler o arquivo CSV de Google Preço dados data = pd. read_csv(data_file) # Insira a coluna de "Date" no início da lista de colunas para que possamos facilmente definir o comprimento de sequência data = data[["Date", "Open"]] # Kranksalieren Zeitreihen lookback = 60 # Número de períodos para olhar em áttrecken X = data. dropna(). as_matrix() X = list(X) X = [X[i: i+lookback] for i in range(lookback, len(X))] X = np. array(X) # X_train conterá todas as entradas anteriores tottalt em X X_train = X[: int(0. 8 * len(X))] # Esta linha reshape X_train para uma forma apropriada para ser passada para begas X_train = X_train. reshape((X_train. shape[0], lookback, 1)) ``` ## Divisão dos dados de treinamento e teste ```python # Configuração dos dados de treinamento e teste y_train = data. dropna(). iloc[lookback: ]. as_matrix() y_test = data. dropna(). iloc[-lookup: ]. as_matrix() ``` ## Configuração do modelo LSTM Iniciamos com a criação de um objeto de sequência, que nos ayuda a organizar os $|$ capas e $|$ funcionalidades do modelo. ```python # Inicialização do modelo de regressão LSTM model = Sequential() ``` Adicionamos uma camada LSTM com a quantidade de unidades configurável. Seremos utilizados $-50$ capas em nosso exemplo. ```python model. add(LSTM(units=50, input_shape=(lookback, 1))) ``` Adicionamos a camada regularizaça de dropout com uma taxa de dropout configurável. Aqui, usaremos uma taxa de dropout de 0. 25. ```python model. add(Dropout(0. 25)) ``` Nós repetimos este processo paraobter três camadas LSTM e de dropout. ```python model. add(LSTM(units=50)) model. add(Dropout(0. 25)) model. add(LSTM(units=50)) model. add(Dropout(0. 25)) ``` Finalmente, após a última camada LSTM, adicionamos a camada densa, que fornece a saída final do modelo. ```python model. add(Dense(1)) ``` ## Compilação do modelo e código de treinamento ```python # Compilar o modelo model. compile(loss="mean_squared_error", optimizer="adam") ``` ```python # Treina o modelo com os dados de treinamento model. fit(X_train, y_train, epochs=100, batch_size=32) ``` ## Resultados e forecasts Assim que o modelo termina de treinamento, podemos fazer prévias utilizando os dados de teste. ```python # Fazer prévias com dados de teste e comparar com os dados reais y_test_pred = model. predict(X_test) ``` ## Recusos Para obter uma réplica dos resultados dos gráficos neste tutorial, segue-se uma instrução detalhada sobre os blocos de código e códigos necessários. O código está desenvolvido por Leo Kozlov. - `LeoKozlov. github. io` A data agentis pertence a Leo Kozlov. Dados gerados para fins de demonstração pública, existem maiores conjuntos de dados disponíveis para treinamento em `www. data. gov` . By Leo Kozlov. The data belongs Leo Kozlov. Data generated for public demonstration, larger datasets available for training at www. data. gov . # Arquiteturas de Redes Neurais Este guia lhe levará a uma visão geral de vários tipos de arquiteturas de redes neurais, observando detalhes sobre o Perceptron, Regressão Logística e Redes Neurais Profundas. ## Motivação Biológica As Redes Neurais Artificiais (RNA) foram inspiradas na estrutura e função das neuronas biológicas no cérebro humano. A neurona se compõe basicamente de quatro partes: 1. **Corpo Celular**: Contém o núcleo e outros órgãos necessários para a sobrevivência da neurona. 2. **Dendrites**: Recebem as sinais de outras neuronas. 3. **Axon**: Transmite o sinal de saída da neurona para outras neuronas. 4. **Sinapses**: As junções entre neuronas onde os sinais são transmissores. ## Aproximação Matemática Aproximaremos o comportamento de uma neurona utilizando equações matemáticas. ### Perceptron O Perceptron é o modelo mais simples de uma neurona artificial, primeiramente introduzido nos anos 50. Ele recebe vários entradas, multiplica cada entrada por um peso, soma os pesos das entradas e aplica uma função de ativação ao resultado. y = f(w1*x1 + w2*x2 + . . . + wn*xn) Aqui, `y` representa a saída, `x1, x2, . . . , xn` são as entradas, `w1, w2, . . . , wn` são os pesos e `f` é a função de ativação. ### Regressão Logística A Regressão Logística pode ser vista como um único nível de Perceptron com a função de ativação sigmoide. Ela é usada para problemas de classificação binária. P(y=1 | x1, x2, . . . , xn) = 1 / (1 + e^(-(w1*x1 + w2*x2 + . . . + wn*xn))) Aqui, `P(y=1 | x1, x2, . . . , xn)` representa a probabilidade da saída ser 1, dado os valores de entrada. ### Redes Neurais Profundas As Redes Neurais Profundas (RNP) se compõem de várias camadas de neuronas conectadas intercaladas. Cada camada processa os dados de entrada, e a saída de uma camada serve como entrada para a próxima camada. As RNP são capazes de aprender e generalizar complexos padrões e relações em um conjunto de dados. ## Funções de Ativação As funções de ativação introduzem não linearidade nas redes neurais, permitindo que as mesmas aprendam grandes patrões e relações. Algumas funções de ativação comuns são: 1. **Sigmoide**: Produz um valor entre 0 e 1, representando a probabilidade da saída ser 1. 2. **ReLU (Unidade Linear Retificada)**: Produz o máximo de 0 e a entrada, incentivando esparsidade na rede. 3. **Tanh**: Produz um valor entre -1 e 1, representando o tangente hiperbólica da entrada. ## A construir uma Rede Neural Construiremos uma rede neuronal simples do zero: 1. **Uma Neurona**: Implemente a equação do Perceptron. 2. **Múltiplas Entradas**: Extenda o Perceptron para lidar com múltiplas entradas e pesos. 3. **Múltiplas Camadas**: Coloque várias camadas de neuronas umas nelas conforme cria-se uma rede neuronal profunda. ## Conclusão Neste guia, introduzimos a estrutura básica de redes neurais, discutimos o Perceptron, Regressão Logística e Redes Neurais Profundas, e demonstramos como criar uma rede neuronal do zero. Para obter mais informações, visite nossa página na web no [Simplilearn](https://www.simplilearn.com/). Não hesite em nos perguntar Questionamentos ou explorar nossos cursos. Você também pode postar comentários abaixo no vídeo do YouTube e esperamos que respondamos. Obrigado por se juntar a nós hoje. Se gostou deste vídeo, inscreva-se no canal Simplilearn do YouTube e clique aqui para assistir a vídeos semelhantes. Vamos ficar empolgado e se certificar! --- ### Arquiteturas de Redes Neurais | Tipos de Arquiteturas de Redes Neurais | Redes Neurais | Simplilearn URL: https://www.youtube.com/watch?v=2l4t7bQPBCM Neste tutorial, discutiremos a motivação biológica das Redes Neurais Artificiais (RNA), sua aproximação matemática, e várias arquiteturas de redes neurais, incluindo o Perceptron, Regressão Logística e Redes Neurais Profundas. ### Agenda 1. Motivação Biológica - Corpo Celular - Dendrites - Axon - Sinapses 2. Aproximação Matemática - Perceptron - Equação - Regressão Logística - Equação - Redes Neurais Profundas 3. Funções de Ativação - Sigmoide - ReLU (Unidade Linear Retificada) - Tanh 4. Iniciando uma Rede Neuronal - Uma Neurona - Múltiplas Entradas - Múltiplas Camadas 5. Conclusão - Recursos adicionais - Perguntas - Comentários no vídeo do YouTube 6. References - [Arquiteturas de Redes Neurais](https://www.simplilearn.com/tutorials/machine-learning-tutorial/neural-network-architectures) --- Veja [esta introdução a redes neurais](https://pvs-reek.github.io/RT_INTRO_NeuralNetworks/) (em inglês) se quiser mais detalhes sobre o assunto. Título: Introdução à rede neural artificial (ANN): Estrutura e matemática de um neurônio ============================================================================================================= Conteúdo -------- 1. **Rede neural artificial (ANN)**: Uma breve introdução. 2. **Física de um neurônio**: Descrição da estrutura e função dos componentes de um neurônio. 3. **Representação matemática de um neurônio**: Apresentação da matemática usada na representação de um neurônio. 4. **Um neurônio simples**: Descrição de um neurônio simples, aperfeiçoado matematicamente. 5. **Uma rede neural com vários neurônios**: Análise de como a matemática se aplica a redes neurais com vários neurônios. 6. **Ativação de um neurônIO**: Explicação de como os neurônios se ativam na rede neural artificial. 7. **Diferentes ativações de função**: Análise de várias funções de ativação, como relacionadas à rede neural artificial. 8. **Parte final**: Sintetização dos conceitos apresentados e abordagem para entender o funcionamento de uma rede neural artificial. 1. **Rede neural artificial (ANN)**: Uma breve introdução ----------------------------------------------------- A rede neural artificial (ANN) é uma das técnicas mais populares e efetivas no aprendizado automático. Útil para resolver problemas complexos com grandes quantidades de dados, tais como a classificação de imóveis, predição de preços e reconhecimento de imagem. No entanto, a rede neural artificial é baseada em um modelo simplificado do sistema nervoso humano, composta de um grande número de núcleos de computação reunidos em pelotões chamados camadas. 2. **Física de um neurônio** --------------------------- De forma geral, um neurônio se compõe de vários componentes, aqui descritos: - **Corpo celular**: O centro do neurônio responsável pela produção de proteínas e natransmissão de informação elétrica. - **Axônio**: O extremo longo do neurônio onde a informação é transmitida para outros neurônios. - **Sinapse**: A junção entre dois neurônios, onde o axônio de um neurônio transmite sua produção a um dendrítico de outro. - **Dendríticos**: Os tipos de ramificações presentes nos neurônios que permitem a recepção de uma transmissão elétrica por outros neurônios. 3. **Representação matemática de um neurônIO** ---------------------------------------------- Os neurônios são representados matematicamente por suas partes individuais. Os parâmetros mais importantes são: - **Pulseio**: A quantidade de pulso sinalizado viação de outros neurônios maior para o neurônio em questão. - **Peso**: O peso da conexão entre os neurônios é representado por um número ($w$). O peso significa como fortes as conexões são entre os neurônios. - **Suma**: A soma do produto de each input e seu peso, calcelado em uma soma: $z = \sum_i w_i x_i$. - **Ativação do neurônio**: A função do neurônion São utilizadas para medir se ou não a ativação ocorre, de forma que é creditido ao neurônio em questão como uma new output. A função de ativação mais comum é a função do qual a série sigmoidal $\sigma(x) = \frac{1}{1+e^{-x}}$. 4. **Um neurônio simples** -------------------------- A função do neurônion simples pode ser apresentada como a seguinte equação: $a = \sigma\left(\sum_i w_i x_i + b\right)$ Em que $a$ é a qual output do neurônio, $w_i$ é o peso $i$-ésimo, $x_i$ é o input $i$-ésimo e $b$ é o termo de estabilização (incluído apenas para resolver alguns problemas com inputs pequenos ou zeros). O termo de estabilização serve como um pequeno pulso básico, caso a soma dos inputs e pesos esteja perto de zero, resultando o output $a$ ser positivo. 5. **Uma rede neural com vários neurônios** ------------------------------------------- Uma rede neural mais complexa contém vários neurônios organizados em camadas, interconectados de forma que quando dados entrassem nessa rede, os valores de output produzidos pelo primeiro neurônio seriam utilizados como inputs para o segundo neurônio, e assim por diante. A representação de uma rede neural de vários neurônios é apresentada pela equação: $z_j = \sum_i w_{ji} a_i + b_j$ $a_j = \sigma(z_j)$ Em que $j$ indica a quantã camada, e $i$ indica a quantá camada anterior. A quantidade de neurônios e camadas é flexível e definida pelo usuário, de acordo com a demanda do problema. 6. **Ativação de um neurônio** ------------------------------ Quando o valor de entrada ($z_j$) de um neurônio restante acima ou abaixo de algum valor específico, o neurônio se ativa ou não. Em particular, a função de ativação mais simples, um função de passo binário, retorna um valor de 1 caso os valores $z_j$ estejam acima desse valor específico, ou um valor de 0 caso os valores $z_j$ estejam abaixo, como uma resposta binária. 7. **Diferentes ativações de função** -------------------------------------- As diferentes funções de ativação são utilizadas para produzir um output de diferentes natureza da rede neural. - Função de ativação de passo binário: $f(x)=\begin{cases} 1, & \text{Se }\, x>=0 \\ 0, & \text{Se }\, x<0 \end{cases}$ - Função de série sigmoidal: $\sigma(x) = \frac{1}{1+e^{-x}}$ - Função tangente hiperbólica: $tanh(x) = \frac{e^{x} - e^{-x}}{e^{x} + e^{-x}}$ - Função de nullgrença: $ReLU(x)=max(0, x)$ Essas funções são utilizadas para se obter valores de output diferentes para uma rede neural, dependendo da demanda do problema. 8. **Conclusão** ---------------- Este artigo forneceu uma visão geral da rede neural artificial, tendo como objetivo auxiliarYou na compreensão daquela técnica de machine learning. Para obter mais informações específicas sobre os treinamento de redes neurais, olhar para [aqui](https://www.google.com). # Tutorial de Aprendizagem Profunda: Entendendo Redes Neurais e Aprendizagem Profunda Este tutorial abordará o que é aprendizagem profunda, o que é uma rede neuronal, diversos conceitos relacionados à aprendizagem profunda, seguindo-se uma demonstração usando Python para construir uma rede neuronal. ## O Que é Aprendizagem Profunda? * A aprendizagem profunda é um tipo de aprendizagem de máquinas que modela as funções do cérebro humano para permitir que as máquinas possam processar e aprender de grande volumes de dados estruturados e não estruturados. * Ela utiliza redes neurais artificiais inspiradas na estrutura e função de neurônios biológicos e suas redes interligadas no cérebro humano. ! [Estrutura simplificada da rede neuronal do cérebro humano](http://www.sciencemag.org/news/2014/03/artificial-brains-and-dreaming) * Enquanto que o cérebro humano é muito mais complexo do que as redes neurais artificiais atuais, a sua estrutura básica envolve dendrites (entradas), corpos celulares (núcleo), sinapses (criando pesos) e axônios (criando saídas). ## Inteligência Artificial (IA) e Aprendizagem de Máquina * A Inteligência Artificial é um método de construir máquinas inteligentes capazes de executar tarefas que normalmente requerem inteligência humana, como visão por computador, reconhecimento de fala, tomadas de decisão e aprendizado. * A Aprendizagem de Máquina é uma subcategoria de IA que permite que as máquinas aprendam e melhorem com a experiência, ao identificar automaticamente padrões em dados, sem ser explicitamente programado para isso. ## Aprendizagem Profunda versus Aprendizagem de Máquina * A aprendizagem profunda é um subcampo de aprendizagem de máquina que é usado para extrair padrões complexos a partir de grande elevações de dados, como o processamento de imagens, reconhecimento de fala e o processamento de linguagem natural. * Em comparação com os modelos de regressão linear, modelos de aprendizagem profunda podem identificar relações mais complexas em dados. ## O Desempenho da Aprendizagem Profunda * O desempenho da aprendizagem profunda se melhora significativamente ao aumentar o volume de dados. Por exemplo, se você tem um grande conjunto de dados de imagens de diferentes tipos de caramujos, em comparação com um conjunto de dados de números na bolsa de valores, a sua rede neural terá muito mais dificuldade em identificar caramujos desde que as imagens variam em tons de cor, sombra e outras características. ## O Que é uma Rede Neuronal? * Uma rede neuronal típica consiste em várias camadas: camada de entrada, camadas ocultas e camada de saída. * Na camada de entrada, definimos as características de entrada, como x1, x2, x3 na ilustração acima. * As camadas ocultas são onde os cálculos são realizados, transformando as entradas em saídas, que são as previsões ou estimativas. * A camada de saída fornece as previsões finais ou saídas baseadas nos cálculos nas camadas ocultas. ## Como funciona uma Rede Neuronal? * As redes neurais funcionam computando a soma ponderada de suas entradas, seguindo-se aplicação de uma função de ativação para criar a saída de cada neurônio. * As pesos (sinapses) são modificados durante o processo de aprendizagem para otimizar a precisão de previsão. * O backpropagation é um algoritmo usado para treinar redes neurais, que computa o erro entre a saída atual e a previsão, e atualiza os pesos baseado neste erro. * As funções de custo como a taxa média quadrativa do erro (MSE) são usadas para avaliar o desempenho da rede neuronal. ## Tipos de Redes Neuronais * Existem vários tipos de redes neurais, incluindo: 1. Redes neuronais de feedforward 2. Redes neuronais recurrentes (RNN) 3. Redes neuronais convolucionais (CNN) 4. Redes neuronais de longo prazo (LSTM) ## Rede Neuronal com Python Neste tutorial, demonstraremos a construção de uma rede neuronal usando Python e TensorFlow para reconhecer números escritos à mão. Entre [Aprenda Simplesmente](https://www.youtube.com/watch?v=MJNkCmoSkbo) para saber mais sobre este tutorial, praticá-lo por conta própria e para obter tópicos aprofundados. ```markdown ## Referências - [A Poderosa Explicação dos Convolutional Neural Networks (CNN) - TensorFlow & Keras (Aprendizado Profundo 101) - Canal de Vídeos Code Bullet YouTube](https://www.youtube.com/watch?v=lw4rIh3Bf80) - [Aprendizado Profundo - O que você precisa saber | Siraj Raval (Python AI) - Canal de Vídeos Code Bullet YouTube](https://www.youtube.com/watch?v=5hqvCyqNW60) ``` ```markdown # Redes Neurais: Introdução Geral Este documento fornece uma visão geral básica sobre redes neurais, com ênfase na sua estrutura e nos conceitos principais. ## Camada de Entrada A camada de entrada é responsável por aceitar entradas em formatos variados. ## Camadas Ocultas Cada camada oculta contém múltiplos nós, conhecidos como neurônios, responsáveis por extrair características e padrões ocultos dos dados. Estas características são importantes, pois normalmente consideramos cada característica como entrada individual. Cada nó gera um número que não possui representação específica, mas se transforma numa forma de olhar por somas as características individuais e criar um valor de importância. ### Ligações entre Neurônios Cada nó da primeira linha está ligado com todos os nós da segunda linha na camada oculta. Se existisse outra camada oculta, tudo no primeiro liar se conectaria com a segunda camada oculta, e então tudo na segunda camada oculta se conectaria às saídas. ### Redes Neurais Convoluciónais (CNN) As CNNs analisam as janelas e somam os números que as compõem. Quando começamos a entrar nos diferentes aspectos do que podemos fazer e como construímos redes neurais, há muita complexidade. ## Perceptron O perceptron é um algoritmo de classificação binária propositado por Frank Rosenblatt. Ele inclui constantes, entradas, pesos, soma ponderada, função de ativação e uma saída de 0 ou 1. ### Constantes Nos termos do perceptron, as constantes incluem uma constante para o bias, que é indispensável. Nos elementos Euclideanos do espaço, esta constante é o intercepto do eixo y, e é essencial para ajustar as entradas. ### Função de Ativação Existem muitas formas de fazer uma função de ativação, mas este exemplo mostra a forma mais comum: a função de ativação verifica se o resultado da função de somatória é superior a zero ou não. ## Aprendizado Profundo O erro na rede é estimado usando a função de custo e a técnica de backpropagação é utilizada para melhorar as performances. Na algoritmo de backpropagação, a função de custo é minimaizada alterando os pesos e os biaises na rede. ## Epochs O número de epochs é um fator importante a considerar. Um epoch é um conjunto completo de dados que você tem que passar antes de repetir e passar de novo os mesmos dados. O erro é propagado regressivamente até que uma erro suficientemente pequena seja alcançada. ## Tipos Diferentes de Redes Neurais - GAN (Rede Geral Adversarial) - DBN (Rede Credível Profunda) - RBFN (Rede Neuronal com Bases Radiais) - Auto-Encoder - RNN (Rede Neuronal Recorrente) - LSTM (Rede Recorrente Neuronal com Memória Longa Termo) Cada tipo de rede neuronal possui seu propósito específico e suas funções. Há agora tantas variantes que existe mesclas de variantes, portanto é necessário escolher a correta para o seu projeto específico. ## Bibliotecas de Aprendizado Profundo - TensorFlow - Keras - PyTorch - DL4J Estas são todas bibliotecas diferentes de aprendizado profundo que estão em atualmente em uso popular para aplicações de aprendizado profundo. Existem muitas mais, e novas estão sendo desenvolvidas todo o tempo. ## Conclusão Neste documento, fornecemos uma visão geral básica sobre redes neurais, com ênfase na sua estrutura e nos conceitos principais. Para uma melhor compreensão, é recomendado treinar e construir redes neurais usando as bibliotecas de aprendizado profundo populares, como TensorFlow ou PyTorch. --- ``` # TensorFlow e Análise de Dados com Queixas de Consumidores Este tutorial foca no trabalho com TensorFlow para classificação de texto utilizando dados de queixas de consumidores. ## Pré-requisitos - Python 3. 6 (TensorFlow talvez não esteja completamente integrado com Python 3. 7 ou 3. 8 ainda) - TensorFlow 2. 1. 0 ## Importação de bibliotecas necessárias ```python from __future__ import absolute_import, division, print_function import pandas as pd from sklearn. model_selection import train_test_split from tensorflow. keras. preprocessing. text import Tokenizer from tensorflow. keras. preprocessing. sequence import pad_sequences ``` ## Preparação de Dados Entraremos no uso do dataset `consumercomplaints. csv`. Se desejar uma cópia deste arquivo para sua própria análise, envie uma mensagem para Learn, e eles estarão felizes em lhe enviar uma cópia. ```python df = pd. read_csv('consumercomplaints. csv') ``` ### Visão Geral dos Dados O dataset contém colunas como `date_received`, `product`, e `consumer_complaint_narrative`. Neste tutorial, focaremos nas colunas `consumer_complaint_narrative` e `product`. ### Remoção de Valores Nulos ```python df = df. dropna(subset=['consumer_complaint_narrative']) ``` ### Divisão dos Dados em Conjuntos Treino e Teste ```python X_train, X_test, y_train, y_test = train_test_split(df['consumer_complaint_narrative'], df['product'], test_size=0. 2) ``` ### Tokenização de Texto Utilizaremos o objeto `Tokenizer` para converter texto em um formato que o computador possa entender. ```python max_words = 1000 tokenizer = Tokenizer(num_words=max_words, oov_token='<OOV>') tokenizer. fit_on_texts(X_train) ``` ### Conversão de Texto em Sequências ```python X_train = tokenizer. texts_to_sequences(X_train) X_test = tokenizer. texts_to_sequences(X_test) ``` ### Ajuste das Sequências ```python X_train = pad_sequences(X_train, padding='post', maxlen=max_words) X_test = pad_sequences(X_test, padding='post', maxlen=max_words) ``` ### One-Hot Encoding ```python from keras. utils import to_categorical y_train = to_categorical(y_train) y_test = to_categorical(y_test) ``` Com os dados preparados, você pode agora prosseguir a construção e treinamento do seu modelo de classificação de texto utilizando TensorFlow. # Classificação de Texto usando sklearn Este tutorial explica como processar texto e classificá-lo usando ferramentas do `scikit-learn`. Neste exemplo, vamos usar um conjunto de dados de relatórios de crédito para classificar as reconduções de crédito. ## Encondando os dados Primeiro, convertemos as fraudes e os créditos válidos de um formato de string para um formato numérico usando o `LabelEncoder` do `scikit-learn`. ```python from sklearn. preprocessing import LabelEncoder encoder_de_rotulos = LabelEncoder() encoder_de_rotulos. fit(y) y_treino = encoder_de_rotulos. transform(y_treino) y_teste = encoder_de_rotulos. transform(y_teste) ``` Leia-se esta seção se você quiser saber mais sobre o `LabelEncoder`. ## Tokenizando o texto Para que o modelo possa processar o texto, precisamos tokenizar o texto em um conjunto de palavras ou caracteres. Este exemplo gera um tokenizador que limita a quantidade de palavras para 1000: ```python from sklearn. feature_extraction. text import CountVectorizer vectorizador = CountVectorizer(max_features=1000) X_treino = vectorizador. fit_transform(X_treino) X_teste = vectorizador. transform(X_teste) ``` Leia-se esta seção se você quiser saber mais sobre o `CountVectorizer`. ## Modelo de texto classificado Usaremos um modelo neural rede profunda para classificar o texto. Primeiro, importe as bibliotecas necessárias e defina o modelo: ```python from keras. models import Sequential from keras. layers import Dense, Embedding, Activation, Dropout from keras. optimizers import Adam modelo = Sequential() modelo. add(Embedding(10000, 128)) modelo. add(Activation('relu')) modelo. add(Dropout(0. 5)) modelo. add(Dense(512)) modelo. add(Activation('relu')) modelo. add(Dropout(0. 5)) modelo. add(Dense(tamanho_do_dataset)) modelo. add(Activation('softmax')) modelo. compile(optimizer=Adam(), loss='categorical_crossentropy', metrics=['accuracy']) ``` Leia-se esta seção se você quiser saber mais sobre neural rede profunda. ## Treinar o modelo Agora, treinaremos o modelo usando a função `fit` do modelo: ```python modelo. fit(X_treino, y_treino, epochs=5, batch_size=32) ``` Leia-se esta seção se você quiser saber mais sobre o `fit` do modelo. ## Avaliando o modelo Por fim, sobrevocê poderá avaliar o modelo com uma função `evaluate`: ```python pontuacao = modelo. evaluate(X_teste, y_teste, verbose=0) print("Perda de teste: ", pontuacao[0]) print("Acuidade de teste: ", pontuacao[1]) ``` Leia-se esta seção se você quiser saber mais sobre a função `evaluate`. Observação: Este exemplo fornece apenas uma introdução aos conceitos básicos de classificação de texto usando ferramentas do `scikit-learn`. Para construir seu próprio modelo personalizado, você poderá precisar estudar mais sobre teoria do caos, erro médio quadrado, redes neurais, e otimizadores. ## Histórico de revisão - 11/20/2022: At # Mortgage vs. Debt Collection: Um Demonstração de Aprendizagem Profunda sobre Classificação de Texto Esta demonstração mostra a capacidade de um modelo de aprendizagem profunda de classificar texto, com foco na diferença entre queixas de hipoteca e coleta de dívidas. ## Rótulos Preditos Ao analisar esta queixa da pessoa, o rótulo preditado foi `hipoteca`. Porém, era de fato uma coleta de dívida, relacionada especificamente a um cartão de crédito. ``` Tive investido uma queixa com a Capital One bank (pontos e pontos e pontos) e ele diz "oh cartão de crédito", mas de fato é uma coleta de dívida. ``` O rótulo real para este caso era `coleta de dívida`. ## Rebuilding Credit com Cartões de Crédito A pessoa abriu uma carta Barclay para ajudar a reconstruir o seu crédito. ``` Aberto uma carta Barclay para ajudar a reconstruir o meu crédito. ``` ## Configuração de Texto e Análise de Sentimentos A configuração de texto e análise de sentimentos são aspectos essenciais deste modelo de aprendizagem profunda. A análise de sentimentos ajuda a determinar se alguém tem uma opinção positiva ou negativa em torno de um determinado tema. ``` O sentimento é uma coisa muito importante, há bibliotecas inteiras por aí se alguém se sente positivo ou negativo em relação a qualquer coisa. ``` ## Previsão de Acções de Valores O modelo também pode ser usado para prever trendes de acções por analisar alimentação de sentimentos em valores diferentes de acções e publicações. ``` Quero alguns códigos de programação para ações, então volto para isso muitas vezes, achando sentimentos de alimentação em valores diferentes de acções e diferentes acções em publicações nacionais em geral, ajuda a tentar prever o que vai acontecer com a ação, o que será feito em compra e venda de ações. ``` ## Previsão de Queixas Com este modelo, podemos agora prever e tentar entender a natureza das queixas. ``` A mesma coisa aqui podemos prever suas queixas e tentar descobrir o que eles estão queixando. ``` ## Apropriação em Rede Neural Esta seção fornece uma introdução à apropriação e regra do mínimo mundial em redes neurais. ### Algoritmo de Apropriação em Layer-by-Layer Explicado para Iniciantes | Simplilearn [Apropriação em Rede Neural](https://www.youtube.com/watch?v=GltT9b31fRY) #### Introdução Bem-vindo a Apropriação e Regra do Mínimo Mundo na Simplilearn's (www. simplylearn. com certifique-se de certificação, avance em carreira). Em este vídeo, discutiremos sobre apropriação e regra do mínimo mundial em redes neurais. #### Treino da Rede Começaremos por treinar uma rede simples a reconhecer as letras de chapéu (a, b, e c). A entrada é apresentada como uma imagem de 28x28 pixels, e a rede faz uma previsão inicial com valores aleatórios designados a cada canal. #### Propagação em Favor da Rede Cada nó adiciona os valores, e a rede faz uma previsão. ``` Cada nó adiciona os seus valores e daí a Rede prevê esse input como B com uma probabilidade de 0. 5 ``` #### Calculação de Erro As probabilidades previstas são comparadas as probabilidades reais, e os erros são calculados. ``` O erro é apenas a diferença entre o real e previsto. ``` #### Apropriação em Rede As informações são transmitidas de volta pela rede, e os pesos são ajustados para minimizar a perda na previsão. ``` Pesos por toda a rede são ajustados de forma a minimizar a perda na previsão. ``` #### Treinamento da Rede A rede é treinada com múltiplas entradas até que seja capaz de prever com alta precisão. ``` Trainamos a Rede com múltiplas entradas até se tornar capaz de prever com alta precisão. ``` #### Previsão de Saídas com Entradas Criaremos uma rede para prever as saídas com as entradas. ``` Temos uma entrada zero, queremos uma saída de zero, temos uma entrada de um, queremos seis, 2 multiplicado por 1 isolado deve ser 18, e quatro é 24. ``` #### Encontrar o Peso Appropriado A rede começa a treinar a si mesma escolhendo um valor aleatório para w. ``` A Rede começa a treinar a si mesmo escolhendo um valor aleatório para w. ``` #### Função de Perda A função de perda é uma medida de erro que define o Erro perto de comparar a saída prevista com a saída real. ``` A função de perda é apenas a medida de erro que define o Erro de comparar a saída prevista com a saída real. ``` # Curso Completo sobre Redes Neurais | Tutorial de Redes Neurais para Iniciantes | Redes Neurais | Simplilearn URL: https://www.youtube.com/watch?v=ob1yS9g-Zcs Idioma: en As Redes Neurais são sistemas de computação comumente usados em aprendizado profundo e são inspirados na estrutura e função do cérebro humano. Elas são utilizadas para encontrar soluções para problemas para os quais o método algorítmico é caro ou não existe. As Redes Neurais aprendem por exemplo e não precisam ser programadas explicitamente. **Bem-vindo ao Curso Completo de Redes Neurais por Simplilearn** Antes de começar, certifique-se de assinar ao nosso canal e clique no icone de sino para não perder uma atualização. Em primeiro lugar, vamos entender os fundamentos de Redes Neurais e ver sua implementação prática. Em seguida, aprenderemos como o backpropagation e o descenso de gradiente funcionam. Por fim, vamos entender os conceitos e a implementação prática de Redes Neurais convolucionais e recorrentes. Vemos primeiro um pequeno vídeo animado para entender melhor as Redes Neurais: **Ultima Verão**, a minha família e eu visitamos a Rússia. Mesmo que nenhum deles podia ler russo, não tivemos nenhuma dificuldade para encontrar o nosso caminho; tudo graças à tradução em tempo real de tábuas em russo para inglês feita pelo Google. Isso é apenas uma das muitas aplicações de Redes Neurais. As Redes Neurais formam a base do aprendizado profundo, uma subárea do aprendizado por máquina onde os algoritmos são inspirados na estrutura do cérebro humano. As Redes Neurais recebem dados, se treinam para reconhecer padrões em esses dados e em seguida preveem saídas para um conjunto de dados semelhante. Vamos entender como isso é feito: **Construa uma rede neuronal que distinga entre um quadrilátero, um círculo e um triângulo. ** As Redes Neurais são compostas por camadas de neurônios, estes neurônios são as unidades de processamento principais da rede. - Primeiro, temos a camada de entrada que recebe a entrada. - A camada de saída previsula nossa saída final. - Existem camadas intermediárias, chamadas de camadas ocultas, que realizam a maioria das cálculos necessários à nossa rede. Aqui está uma imagem de um círculo. Essa imagem é composta de 28 por 28 pixels, que fazem um total de 784 pixels. Cada pixel é fornecido como entrada para cada neurônio da primeira camada. Os neurônios de uma camada são conectados a neurônios de camadas posteriores através de **canais**. Cada um desses canais é atribuído um valor numérico conhecido como peso. Os entrados são multiplicados pelo peso correspondente e sua soma é enviada como entrada para os neurônios da camada oculta. Cada um desses neurônios está associado a um valor numérico chamado de parâmetro de bias, que é então somado à soma de entrada. Esse valor é então passado por uma função de ativação chamada função de ativação. O resultado da função de ativação determina se o neurônio em particular é ativo ou não. Um neurônio ativo transfere dados para neurônios da camada posterior nesse modo, a informação é propagada pela rede, o que é chamado de propagação para frente. Na camada de saída, o neurônio com o maior valor ativa-se e determina a saída. Os valores são basicamente uma probabilidade; aqui, nossa neurônio associado com **quadrilátero** tem o maior valor, portanto, esse é o valor previsualizado pela rede neuronal. Obviamente, com um único olhar, podemos ver que a rede neuronal fez um errado pré-dicionamento. No entanto, como a rede ainda não foi treinada, como ela determina isso? Observe que nossa rede ainda não está treinada. Durante o processo de treinamento, além do entrada, nossa rede também recebe a saída fornecida. A saída predita é comparada à saída real para realizar o erro de predição. O íncremento do erro indica o erro ao qual nos equiramos, e o sinal sugerindo se os valores preditos são maiores ou menores do que o esperado. Os ícones aqui dão uma indicação da direção e do íncremento do erro para reduzir o erro. Essa informação é então transmitida de forma inversa através da nossa rede, o que é conhecido como propagação em três direções. Agora, baseado nessa informação, os pesos são ajustados. Este ciclo de propagação direta e propagação em três direções é iterativamente realizado com várias entradas. O processo prossegue até que os pesos são atribuídos de forma que a rede possa prever os quads corretamente. Em muitos casos, isso termina nosso processo de treinamento. Você provávelmente se perguntaria quanto tempo esse processo de treinamento leva. Honestamente, Redes Neurais podem levar horas, dias ou meses para treinamento. No entanto, o tempo é um compromisso razoável quando comparado ao seu escopo. **Lembre-se** que quando estamos fazendo a propagação em três direções, estamos não só olhando em uma letra `A`. Estamos olhando em centenas, milhares ou até mesmas milhões de letras `A`. Geralmente, apropriamos-se apenas do máximo de perda que é propagado para trás; nossas correções são extremamente pequenas, pois, se um deles está errado, não queremos criar uma b유ias. Vamos nos concentrar no mínimo de perda para nossa variável `a`. E você pode ver aqui que estamos considerando isso; assumimos para baixo ser seu gráfico para a perda de predição com a variável `a` comparado com o gráfico real, e nossa perda de `a` é 0, 49, 0, 16, 0, 004, e você pode ver que faz uma boa curva onde podemos achar o fundo desse gráfico. Gosto deste gráfico que eles mostram que a curva não descansa em onde `y` é igual a zero porque raramente você tem um bom ajuste no lugar. Assim, as pontuações escolhidas aleatoriamente para o gráfico são propagadas para a rede para ajustar os pesos. Podemos voltar através da rede e ajustar esses pesos até que encontrem essa menor validação. A rede é novamente executada com os novos pesos. Este processo é repetido várias vezes até fornecer pré-diciões precisas. Os pesos são ajustados mais a fim de identificar `B` e `C`, o que é interessante porque você realmente os faz em conjunto. Assim, como o erro segue voltando, você basicamente encontra o erro total para todas as entradas vindas, e ele é propagado de volta. Ou seja, a perda geral precisa se afastar de palavra `erro` porque ela não está tanto sobre o erro; é sobre a perda. Os pesos são ajustados ainda mais para identificar `B` e `C2`. **Muitas vezes, você realmente faz deles todos ao mesmo tempo, mas você ajusta os pesos `a, b` e `c` como eu disse acima como parte da descente de gradiente e propagação em três direções. ** A nossa rede está completamente treinada, e nós já ensinamos-na a identificar `a`, `b` e `c`. Ao longo do caminho, um dos interessantes sobre as Redes Neurais é que o processo de treinamento leva muito tempo mais longo que o processo de predição. Você pode planejar um destes treinadores de rede neuronal para fazer trabalho substancialmente mais longo, pois você passa por milhares de pontos de dados, enquanto que quando você executa realmente, ele é bem rápido, o que torna essas coisas extremamente úteis e apenas uma enorme parte do mundo atual da Computação. Quero agradecer a você hoje por ter se juntado a nós para mais informações; Visit [www. simplilearn](http://www.s-simplylearn) para obter mais informações. Enviemos suas perguntas a nós, e voltaremos a responder --- ### Curso Completo sobre Redes Neurais - Tutorial de Redes Neurais para Iniciantes - Redes Neurais - Simplilearn [Conheça, avance](http://www.s-simplylearn) Obrigado pela visualização! Se você gostou deste vídeo, inscreva-se no canal de Youtube da Simplilearn e clique [aqui](http://www.s-simplylearn) para assistir vídeos semelhantes sobre redes neurais. Se tiver alguma dúvida, deixe-nos um comentário! Por favor, quadros, Équipe Simplilearn # Aprendizagem Profunda e Redes Neurais Artificiais ## Introdução A Aprendizagem Profunda é um subconjunto da Aprendizagem de Máquina que se concentra na criação de redes neurais artificiais com múltiplas camadas. Essas redes se assemelham à estrutura e ao funcionamento do cérebro humano, permitindo aos computadores aprender a partir dos dados de uma maneira que se aproxima da aprendizagem humana. Para entender as redes neurais artificiais, é primeiramente necessário entender como funciona um neurônio real. ### Neurônios O neurônio é constituído por várias partes, incluindo: - Dendrites: Entrada para o neurônio, onde a informação é recebida de outros neurônios. - Corpo da célula: Local do processamento da informação. - Axão: Saída do neurônio, que transporta a informação processada para outros neurônios. - Flanges: Ligações entre o axão de um neurônio e os dendrites ou cabelos de entrada do neurônio próximo. ### Redes Neurais Artificiais Uma rede neural artificial contém três camadas principais: a camada de entrada, as camadas ocultas e a camada de saída. - A camada de entrada: Um array de dados, cada ponto branco representando uma característica (p. ex. , um pixel numa imagem). - As camadas ocultas: Cada ligação que se conecta a camadas ocultas representa valores especiais (pesos), que somam todos os valores da camada de entrada. - A camada de saída: Aquele local do processamento ocorre aqui, com a saída de cada camada oculta sendo a entrada para a próxima até que a saída final seja gerada. ### Reconhecimento de Falas nas Redes Neurais No reconhecimento de falas, a camada de entrada recebe um padrão de som (representado por uma frase), que é então processado pelas camadas ocultas. A rede neural reconhece o padrão de fala identificando cada onda de som como um padrão distinto e determinando a frase mais provável que está sendo pronunciada com base no acumulado de padrões. ### Vantagens das Redes Neurais Artificiais As Redes Neurais Artificiais têm algumas vantagens chaves: - Saídas não limitadas: A rede neural pode processar e aprender a partir dos dados sem ser explicitamente contado o que o output correto deve ser. - Tolerância a falhas: Uma rede neural de computador pode diagnosticar e reparar a si mesma, tornando-a muito tolerante às falhas. - Sistemas não lineares: Redes neurais podem encontrar atalhos para chegar a soluções demoradas computacionalmente, fazendo com que sejam muito eficientes. ## Aplicações Atuais das Redes Neurais Artificiais As Redes Neurais Artificiais têm inúmeras aplicações no mundo real, sendo algumas: 1. Reconhecimento de Escrita à Mão: Convertendo caracteres escritos à mão na forma digital para facilitar a sua reconhecimento e processamento. 2. Previsão de Bolsa de Valores: Análise de tendências e previsão de preços para ajudar os corretores de bolsa. 3. Problema do Viajante: Encontrando o caminho ótimo para viajar entre várias cidades, salvando tempo e recursos. 4. Compressão de Imagens: Armazenamento, criptografia e reprodução de imagens para otimizar o armazenamento e recuperação. ### O Futuro da Aprendizagem Profunda O futuro da Aprendizagem Profunda é promissor, com várias possibilidades de aplicações nelas, como escolhas personalizadas para clientes, assistantes virtuais hiper intelligence, novos métodos de aprendizagem, redes neurais mais rápidas e a integração dessas redes nos diversos campos, como em medicina, agricultura e física. ## Como Funciona uma Rede Neural? As redes neurais funcionam processando dados por várias camadas, com cada camada construída sobre a outra para criar uma representação dos dados de entrada que pode ser utilizada para previsões ou tomada de decisão. --- Observação especial: Este texto representa uma explicação simples, grosseira da rede neural e da aprendizagem profunda. Para informações técnicas e aprofundadas, consulte fontes acadêmicas ou literatura especializada. Adicionamos também alguns cabeçalhos geralmente para melhorar a organização e fornecer uma breve explicação geral do assunto. Haverá alguns ajustes no link arbitrário selecionado para uma melhor formatação. As palavras técnicas técnicas sobre o tema foram mantidas inalteradas, bem como os exemplos de comandos e códigos exactamente como estão. # Explicação de Rede Neural ## Introdução Uma rede neural é um modelo computacional inspirado na estrutura do cérebro humano, constituído por camadas interligadas de nós ou "neurônios". Neste exemplo, vamos discutir uma rede simples utilizada para Reconhecimento Optico de Caracteres (OCR) para detectar placas de veículos registrados pelas câmaras de trânsito. ## Componentes da Rede 1. **Camada de Entrada**: Permite que dados entrarem e pega os sinais de entrada. 2. **Camadas Ocultas**: Realizam cálculos e extraem recursos. Neste exemplo, mostramos apenas uma camada oculta, mas poderá ter várias camadas. 3. **Camada de Saída**: Apresenta o resultado final. ## Estrutura da Rede 1. **Camadas Verdes**: Representam a camada de entrada, onde cada ponto corresponde a um pixels na imagem, com valores de ativação que variam de 0 a 1 para pixels brancos e 0 para pixels pretos. 2. **Camadas Laranjas**: Representam as camadas ocultas, com ligações entre as camadas de entrada e oculta atribuídas pesos aleatória. 3. **Camadas Vermelhas**: Representam a camada de saída, apresentando o resultado final. ### Exemplo - Processando uma imagem de veículo 28x28 pixels: - Cada nó possui um valor de ativação representando o valor cinza da correspondente pixel. - Se um pixel for registrado como 0, 82, provavelmente é bastante escuro. - As pixels são apresentadas nos arrays no formato de também os arrays das pixels no local criam entradas da camada de entrada. A camada de entrada é umidimensional enquanto a imagem é bidimensional. - Deve-se convertendo cada linha da imagem creates nas arrays parala abaratilhar os pacotes anteriores de pacotes de rede neural. - A chave é garantir que a imagem coincida com as dimensões de entrada; não pode aumentar o número de pixels de entrada. ## Cálculo - Para cada camada oculta: 1. Faz-se o cálculo do soma ponderado dos entrada. 2. A aplicação da função de ativação é feita para decidir quais nós serão ativados (extração de recurso). ## Funções de Ativação - Função de Sigmoide: Um sobre um mais e^(-x). - Função de Apatência: x >= 0 se Sim, x = 0 se Não. - Função ReLU: f(x) = max(0, x). - Função híperbólica: 1 - e^(-2x) / (1 + e^(-2x)). ## Predição Final O modelo aplica uma função de ativação adequada à camada de saída para prever o resultado. Neste caso, ele identify os caracteres na placa de matrícula. ## Propagação Trás-Cópia e Treinamento O erro na saída é propagada na rede, e os pesos foram ajustados para minimizar a taxa de erro. Dados de treinamento são utilizados para comparar os resultados previstos com os dados originais e ajustam os pesos adequadamente. ## Tipos de Rede Neural Artificial - Rede Neural Alimentada por Entrada Simples (FFNN): A forma mais simples de rede neural, com dados transportando-se apenas em uma direção (entrada a saída). - Outros tipos incluem Redes Neurais Convolucionais (CNN), Redes Neurais Recorrentes (RNN) e Redes de Crença Profundas (DBN). # Redes Neurais Artificiais: Um Olhar Profundo ## Introdução Este documento fornece uma visão detalhada de vários tipos de redes neurais artificiais (RNAs) e suas aplicações. ## Rede Neural de Entrada Direta (RNED) A rede neural de entrada direta é um modelo fundamental que processa informações em uma direção, de nós de entrada através de nós ocultos até nós de saída. ## Rede Neural de Função de Base Radial (RNFRB) A RNFRB é uma forma especializada de RNA que classifica pontos de dados baseados na sua distância de um ponto central. Este modelo é particularmente útil quando os dados de treinamento são limitados e permite a agrupamento de itens semelhantes. ## Rede Neural Autorganizadora (RNA) As RNAs são um tipo de RNA que organiza vetores de entrada em uma representação de baixa dimensão, criando uma topologia que mapeia o espaço de entrada para um espaço de representação. ## Rede Neural Recorrente (RNR) As RNRs são uma classe especial de RNAs que são capazes de manter informação de estado em passos de tempo. Elas são comumente utilizadas em reconhecimento de fala, modelagem de língua e outras tarefas que exigem lidar com dados sequenciais. ## Rede Neural Convolucional (RNC) As RNCs são projetadas para processar dados em estruturas de grade, como imagens, e são particularmente eficazes para tarefas como classificação de imagens, detecção de objetos e reconhecimento facial. ## Rede Neural Modular (RNM) As RNM consistem em várias RNAs trabalhando juntas para alcançar um objetivo comum. Este abordagem permite a integração de vários modelos, cada um otimizado para tarefas específicas. ## Aplicações de RNAs As RNAs encontraram ampla aplicação em vários domínios, incluindo: 1. Sistemas de restauração de energia: Para identificar componentes conectados e corrigir problemas em grandes sistemas de energia. 2. Modelos de conversação de texto para assistentes: Para reconhecer padrões e interpretar comandos do usuário em assistentes como Google Assistant ou Lexis. 3. Processamento de sinais e imagens: Para reconhecimento facial, análise médica e outras tarefas que exigem reconhecimento de padrões. 4. Robótica: Para reconhecer alterações e prever estados futuros, como no voo de um drone ou tomadas de decisão em veículos automatizados. ## Arquitetura em Redes Neurais Modernas As RNAs modernas frequentemente empregam uma arquitetura de pipeline, onde os dados são passados de uma rede neural para outra, permitindo a integração de vários modelos e a exploração de várias configurações. Este abordagem é experimental e criativa e varia de acordo com o domínio específico. ## Caso de Uso: Classificação de Cats vs. Dogs Vamos usar uma rede neural para classificar fotos de gatos e cães. O objetivo é identificar fotos de gatos e cães usando uma rede neural treinada, o que pode ser utilizado em portas automáticas para animais domésticos ou outras aplicações. Este caso de uso será implementado em Python 3. 6. ## Configuração do Ambiente Para trabalhar com Keras, certifique-se de ter TensorFlow, CNTK (Theano, Caffe ou MXNet são opções alternativas), e os pacotes necessários instalados. ```sh pip install numpy scipy scikit-learn Pillow h5py # Aplanando e Dimensionando Imagens para um Classificador Neural Rede Neuronal 2D Este texto discute a importância de estruturar imagens em 2D antes de treinar um modelo de rede neuronal classificador. ## Introdução Neste tutorial, aprenderemos a trabalhar com imagens em 2D para treinar um classificador neural. Começaremos com a justificativa para o processamento de imagens em 2D e discutiremos sobre as ferramentas utilizadas para transformar as imagens de 3D (com três canais de cores) em 2D. O objetivo é simplificar o processamento para que você não se preocupe com as peculiaridades das imagens coloridas. ## Aplanando as Imagens Quando trabalhar com imagens em escala de cinza ou a resolução de todas as imagens é igual, é possível criar uma matriz bidimensional contendo todas as posições individuais das imagens. Porém, quando você pode trabalhar com imagens coloridas e/ou de diferentes resoluções, é importante processar as imagens antes de colocá-las no formato 2D. O processamento 2D serve para converter as imagens coloridas para uma matriz bidimensional (envolvendo todos três canais - vermelho, verde, azul) e para reformatar imagens de diferentes resoluções ao tamanho necessário para o modelo de rede neuronal (que em nossa aplicação será 64x64 pixels). ## Criação do Classificador Neural Antes de começar, vamos criar o nosso classificador neural na seguinte sequência: ```python classifier = Sequential() ``` Em seguida, vamos adicionar nossa primeira camada Conv2D com um kernel de 3x3: ```python classifier. add(Conv2D(32, (3, 3), input_shape = (64, 64, 3))) ``` E adicionaremos a camada de activaion ReLU: ```python classifier. add(Activation('relu')) ``` ## Aplanasndo as Imagens Depois de acrescentar as camadas Conv2D, não recebemos nenhum erro, então a saída do modelo é a mesma saída original. Por este motivo, temos que salvar as imagens em um formato de 2D antes de trabalhá-las no nosso modelo. ```python img = np. expand_dims(img, axis=0) ``` Agora, todo o resto do nosso código é para treinar o nosso classificador neural. ```python # Continuarnos treinando o nosso classificador neural e testando o desempenho. . . ``` Referências --------- - [Redes Neurais Convolucionais (CNNs) para Reconhecimento Visual](https://www.pyimagesearch.com/2018/04/16/convolutional-neural-networks-cnn-for-visual-recognition/) - [Entendendo Redes Neurais](https://arxiv.org/pdf/1312.6199.pdf) - [Tutoriais de TensorFlow](https://www.tensorflow.org/tutorials) # Processamento de Imagem e Sucessão de Dados para Classificação Binária ## Introdução Neste tutorial, iremos passar pelo processo de pré-processamento e organização de dados de imagem para classificação binária usando o `ImageDataGenerator` do Keras. Vamos nos concentrar na reshaping dos dados para nosso setup, na escalonagem das imagens e na criação de conjuntos de treino e teste. ## Pre-processamento e Configuração Inicial Primeiro, vamos importar as bibliotecas necessárias: ```python from keras. preprocessing. image import ImageDataGenerator, array_to_img, img_to_array from keras. utils import to_categorical import numpy as np import os ``` ### Geração de Dados de Treino Em seguida, criaremos um `ImageDataGenerator` para os dados de treino: ```python # Defina o gerador de dados de treino train_datagen = ImageDataGenerator( rescale=1. /255, shear_range=0. 2, zoom_range=0. 2, horizontal_flip=True ) ``` ### Criação do Conjunto de Treino Agora, vamos criar o conjunto de treino usando nosso `train_datagen`: ```python # Crie o conjunto de treino train_generator = train_datagen. flow_from_directory( 'caminho/para/seus/dados_de_treino', # Defina o caminho para os dados de treino target_size=(64, 64), batch_size=32, class_mode='binary' ) ``` ### Geração e Preparação de Dados de Teste De forma semelhante, criaremos um `ImageDataGenerator` para os dados de teste: ```python # Defina o gerador de dados de teste (somente a escalonagem é necessária para os dados de teste) test_datagen = ImageDataGenerator(rescale=1. /255) # Crie o conjunto de teste test_generator = test_datagen. flow_from_directory( 'caminho/para/seus/dados_de_teste', # Defina o caminho para os dados de teste target_size=(64, 64), batch_size=32, class_mode='binary' ) ``` N. B. Não esqueça de substituir `'caminho/para/seus/dados_de_treino'` e `'caminho/para/seus/dados_de_teste'` pelos caminhos reais dos seus conjuntos de dados de treino e teste. ## Explicação do Código Ao longo do código, utilizamos os seguintes componentes-chave: - `ImageDataGenerator`: Gerador de dados de imagem do Keras, utilizado para pré-processar os dados de imagem antes de os alimentar no modelo. - `flow_from_directory`: Função do Keras para carregar fluxo de dados de uma pasta. - `rescale`: Opção utilizada para escalonar os valores de pixel, aqui definida como 1/255 para transformar os dados entre 0 e 1. - `shear_range`: Opção utilizada para aplicar transformação de escamotagem. Aqui, definida como 0. 2. - `zoom_range`: Opção utilizada para aplicar transformação de zoom. Aqui, definida como 0. 2. - `horizontal_flip`: Opção utilizada para aplicar reflexões horizontais às imagens. Definida como True. - `class_mode`: Opção utilizada para definir a codificação dos rótulos de classe. Aqui, definida como 'binary' pois estamos lidando com classificação binária Texto traduzido em português de Portugal e mantendo a formatação Markdown: Entendimento Básico e Algoritmo de Backpropagação de Rede Neural =================================================================== Para modificar a resolução de impressão, modificamos o código para configuração de impressão de 64x64 como mostrado abaixo: Primeiro, vamos atualizar as dimensões de imagem para um tamanho conveniente: ```bash imagem = cv2. resize(imagem, (64, 64)) ``` Inicialize a imagem em um array antes de processar os dados, como antes, para teste e treinamento: ```bash image_array = img_array[. . . , None]. transpose((3, 0, 1, 2)) ``` Modifique a medição da precisão: ```makefile test_accuracy = float(predicted. max(0) == classes. max(0))[0] accuracy_values. append(test_accuracy) ``` Desvendando o modelo de teste para imagens de cães vs gatos: ========================================================= Para distinguir imagens entre gatos e cães, nós seguimoss os passos descritos abaixo: 1. Ajustar a resolução de imagem para um formato padrão de 64x64, eliminando a necessidade de re-localizar imagens para testes individuais ou atualizar bancos de dados de imagens. ```css cv2. resize(image, (64, 64)) ``` 2. Preparar a imagem para que seja um array numérico ( numpy no nosso caso), para manipulação de rede neural eficiente, de forma semelhante a manipulação dos nossos conjuntos de dados de treino e teste iniciais. ```sql img_array = . . . ``` 3. Transpor a matriz de imagem resultante de forma que fique no formato `(batch, canais, linhas, colunas)`. ```diff image_array = . . . . transpose((3, 0, 1, 2)) ``` 4. Conceda predictivas através do algoritmo de rede neural com nosso conjunto de dados transformado: ```diff model. predict_classes(img_array) ``` 5. Rótulo as classes previsíveis ao lado das imagens (isto pode variar consoante os locais especificados das imagens em nossos conjuntos de diretórios) ```less print('Rótulo para a imagem de teste atual é: ', str(labels[classes. max()])) print('O valor de probabilidade é: ', format(prob[0], ". 2%"), " ", prob[classes. max()] * 100) ``` Avaliando a saída da rede: ------------------------------------ Avalie a capacidade da rede na detecção de gatos, cães, ou possíveis calculos errôneos para garantir rótulos de classe adequados e resultados em sistemas comerciais de servidor: 1. Verifique se o desempenho é satisfatório em nosso amostra de teste inicial aleatória no seu computador para comparar com os valores de desempenho comercial esperados: ```diff for test in [0. 1, 0. 1, 0. 1]: # para execuções locais (reproduz nossos treinamentos) accuracy, total = neural_network. predict(validation_set. samples(samples_per_test), sample_weights=[weights for w in validation_set. sample_weights[: int(sample_size/3)]]*test) training_accuracies. append(accuracy*3/2 + (2 - accuracy)/4) # combina previsões de amostras para avaliar o desempenho geral ao longo do conjunto de dados de treino (pesos de cada conjunto escalonados proporcionalmente para propósitos de mediação) total += weights[weights_indices][1: 6] ``` 2. Para avaliações precisas: * Preserve nosso previamente especificado pesos utilizados em nossos servidores de rede neural de produção. ```perl final_validation_set, validation_acc_performance, training_acc_performance = modify_dataset("datasets_cleaned. pickle") ``` * Verifique e armazene os resultados previstos em determinado round, junto com a label ```swift correct_answers, prediction_loss, test_iterations += [int(x[1] == pred_classes[-1]), error[1]/accuracy] for x in enumerate(network. forward(validation_input_imgs, return_all_scores)) validated_values_dict = {f'Teste #{index+1}, Biaise: {network. bias}, Previsão: {predicted. max()} \tRótulo de classe: {test_sets["class labels"][list(test_sets["imgs_arr"]. index(image))}, \t Real: {predictions_sets[x] for x in final_validation_set[3]. indices==[correct_answers]. ravel(). tolist()[0]. indices}\n Erro: {1 - sum(predictions_sets[x ` # Redes Neurais: Propagação por Trás e Descento do Gradiente ## Problema de Um Nó Estamos atualmente trabalhando em um problema envolvendo um nó. Neste momento, a sua rede está treinada e pode ser utilizada para fazer previsões. Vamos agora voltar a nossa primeira exemplo para entender onde a propagação por trás e o descento do gradiente entrem. ! [exemplo de nó único](data: image/png; base64, <seu dado base64 de imagem aqui>) ### Entradas Múltiplas Agora não estamos a olhar para um nó único. Agora temos uma grade de 28x28 ou entradas de 784 a entrar no nível inicial. Dependendo de como você constrwaia a sua rede neural, a camada seguinte pode ter 784 nós ou pode diminuir gradualmente de tamanho de acordo com o que é necessário e o que é necessário para que funcione. ### Computação do Erro e da Perda Como mencionado anteriormente, a saída prevista é comparada com a saída real e aqui podemos ver o erro (real - previsão). A perdas calculamos desta forma: - Perda de 'a': (real - previsão)^2 = 0. 7^2 = 0. 49 - Perda de 'b': (real - previsão)^2 = 0. 5^2 = 0. 25 - E assim por diante. . . ### Iterações Agora temos nossa primeira iteração. Ajustamos os pesos ao longo da rede para reduzir a perda na previsão. #### Propagação por Trás Durante a propagação por trás, não estamos a olhar apenas para uma letra 'a'. Estamos a olhar para centenas de letras 'a'. Normalmente, propagamos a perda indo atrás, apenasengeando uma pequena parte dele, para que nossas ajustes sejam extremamente pequenos. Estamos a fazer isso para evitar criar um preconceito. Várias iterações são executadas em buttress until we find the right value. #### Perda Mínima para a Variável 'a' A focalizamos na perda mínima para nossa variável 'a' e a gráfica employi abaixo. Para simplicidade, aç assume 'f(x)' a nossa gráfice para a perda da previsão com 'x' sendo o número de camadas ocultas. Podemos ver a perda mínima para a variável 'a' cerca de 0. 04. ! [gráfica de perda mínima](data: image/png; base64, <seu dado base64 de imagem aqui>) #### Utilizando a Curva Os pontos aleatoriamente escolhidos na gráfica são propagados para a rede para ajustar os pesos. Poderemos passar pela rede novamente com os novos pesos e repetir este processo várias vezes até fornecer previsões precisas. Isto é extremamente interessante porque as redes neurais possuem uma velocidade de previsão muito rápida ao passar pela rede, por isso, elas se tornaram muito úteis e integrantes integrais em nosso mundo moderno que computa. ### Redes Neurais Convolucionais (CNN) Nesta sessão, vamos ensinar a reconhecer objetos na imagem. O bloco central para o reconhecimento de imagem é a rede neuronal convolucional (CNN). Siga à frente enquanto nós nos afundamos nos níveis individuais da rede neuronal convolucional e implementamos uma implementação de caso de uso usando o CNN. #### Introdução à CNN Começamos nossa introdução à CNN introduzindo seu pioneiro, Jan Lecun, que era o diretor da Faculty AI Research Group e construiu a primeira CNN chamada "LeNet" em 1988. Desde então, as CNNs adentraram em refinamento, e você encontrará algumas camadas da mesma disponível em várias outras estruturas de redes neurais. Divemos em um exemplo. ! [exemplo de flor](data: image/png; base64, <seu dado base64 de imagem aqui>) Neste exemplo, você encontra duas variedades de flores: orquídea e rosa. As imagens são enviadas para a camada de entrada, e os dados são depois processados por todos os diferentes nós da camada seguinte com base em seus pesos e instalação. A camada de saída ativa um nó que identifica a imagem como sendo uma orquídea ou uma rosa, com base em como foi treinada. A CNN é distingui de outras redes neuronais por operação convolucional no seu núcleo. #### Operação Convolucional Em uma CNN, a operação convolucional forma a base de qualquer CNN. Cada imagem é representada como matrizes de valores de pixel. Aqui, temos uma imagem real da seis que é transformada em sua representação em píxel (zeros e uns), onde os uns representam a parte preta da seis e os zeros representam o fundo branco. ! [exemplo do numero 8](data: image/png; base64, <seu dado base64 de imagem aqui>) Conhecendo a rede neuronal convolucional ou como a operação convolucional funciona, vamos passar um passo para trás e olhar em matrizes. Simplificamos a operação e consideramos duas matrizes de uma dimensão A e B. A: é uma matriz de uma dimensão, exemplo: a = [5, 3, 7, 5, 9, 7] B: é uma matriz exemplo: B = [1, 2, 3] No convolução, começamos por multiplicar A por B de elemento a elemento e recuperamos [5, 6, 6, 5, . . . ]. Como as duas matrizes não são da mesma tamanho, estritamos a primeira e olhamos apenas em o segundo array multiplicado apenas por os três primeiros elementos da primeira matriz. A soma do produto é 17. No nosso A * B, o nosso primeiro número na matriz de A * B é 17. Repeatamos este processo várias vezes e cobriremos todas as diferentes entidades em A que correspondem para três different levels of B. Isso ajudará o computador a ver diferentes aspectos da imagem. Vamos compor onde utilizamos esta matemática e como isso funciona em mais detalhes em seções posteriores. Lembram-se, estamos a olhar para uma parte da A e a comparar com B, trazendo o valor a um único matriz (A * B) de uma forma que ajuda o computador a distinguir diferentes factores. Quando juntam entre em como isto, já não é tão intimidadoso quanto pode parecer. # Imagens em Redes Neurais Convolucionais ## Imagens básicas 2D Voltemos aos nossos imagens, discutindo a imagem básica 2D que você pode obter. Considere as seguintes duas imagens: 1. **Símbolo para Backslash** ! [Símbolo Backslash](<backslash-symbol. png>) Quando você pressiona o backslash, a imagem acima será processada. Você pode ver lá que para a imagem do símbolo de Barriga Forcada, o oposto é exibido. Apenas clicando no botão de Barriga Forcada, ela se inverte. Muito básico, não é possível se tornar mais básico do que isso. 2. **Riscado** ! [Riscado Image](<smiley-face-image. png>) Aqui, temos uma imagem mais complexa. Tomamos uma imagem real de um boneco sorridente e o representamos como pixels pretos e brancos. Se esta tivesse sido uma imagem em um computador, seria uma imagem em preto e branco. Como vimos antes, convertemos-a em uma matriz de zeros e um. Enquanto a imagem simples seria apenas uma matriz de apenas quatro pontos, agora temos imagens mais significativas vindas. Não se preocupe, varemos juntar tudo em pouco tempo. ## Lições da Rede Neuronal Convolucional ### Camada de Convolução Na Rede Neuronal Convolucional (CNN), a camada de convolução é o aspecto central da processamento de imagens. É por isso que temos, e alimenta-se diretamente na camada ReLU, que vamos discutir mais tarde. A ReLU não é apenas sobre como a camada é ativada; é sobre a matemática por trás dela que faz os neurônios se ativarem. Vocês verão que outras redes neuronais quando estão sendo usadas por si próprias, utilizam o recurso de ativação apenas para grande quantidade de dados entrando, mas devido ao fato de estarmos processando pequenas quantidades de dados em cada imagem, a camada ReLU funciona excelentemente. Você tem a sua camada de peeling, onde está empilhando os dados. Peeling é um termo matemático utilizado frequentemente em redes neuronais. Eu uso o termo **reduzir** quando eu vindo da parte de map e reduce. Chamaremos todos estes dados através de todos estes redes e então reduziremos. Será extraído e então reuniremos e finalmente temos a camada completamente conectada, onde nossa saída será extraída. ### Camada de Convolução - Matriz de Filtro Uma camada de convolução possui **filtros** e executa uma operação de convolução em cada imagem, que é considerada uma matriz de valores de pixels. Considere uma imagem de 5x5 com apenas valores zero e um. ``` |0 0 0 0 0| |0 1 0 0 0| |0 1 0 0 0| |0 1 0 0 0| |0 0 0 0 0| ``` Claramente, quando estamos lidando com cor, existem várias coisas que aparecem na processamento de cores, mas pretendemos manter tudo simples e apenas manter os pixels em preto e branco. Portanto, temos nossos valores de pixels de imagem. Vamos deslizar a matriz de filtro sobre a imagem e computar o produto escalar para detectar padrões. Poderá se perguntar onde este filtro vem. Isso é ligeiramente confuso porque o filtro é derivado mais tarde. Construímos os filtros quando programamos ou treinamos nossa modelo, portanto, não precisam se preocupar sobre o que o filtro realmente é, mas precisa saber como funciona a camada de convolução, e o que a matriz de filtro faz. Filtro, e você terá mini filtros (não apenas um, terá muitos filtros) que procurarão diferentes aspectos. Abordaremos isto de maneira mais detalhada em pouco tempo sucessivo. Para o momento, se concentrate na forma da matriz de filtro como matriz. Lembra que anteriormente discutimos a multiplicação de matrizes juntas, aqui, temos uma matriz 2D (considerada como uma imagem). Você pode ver que utilizamos o filtro e multiplicamos, na divisão superior esquerda, como mostra a figura abaixo: ``` | 1 * 1 + 0 * 0 + 1 * 0 + 1 * 0 + 0 = 1 | | 0 * 1 + 1 * 1 + 0 * 0 + 0 * 0 + 0 = 1 | | 0 * 1 + 1 * 0 + 0 * 0 + 0 * 0 + 0 = 0 | | 0 * 1 + 1 * 0 + 0 * 0 + 0 * 0 + 0 = 0 | | 0 * 0 + 0 * 0 + 0 * 0 + 0 * 0 + 0 = 0 | ``` Continuamos deslizando a matriz de filtro sobre a imagem, calculando o produto escalar para detectar os padrões. Empurraremos isso, portanto, preveremos a primeira e deslizaremos para uma notch, preveremos a segunda e assim por diante. Esta nova matriz, que é a mesma dimensão da matriz de filtro, reduziu a imagem, e a qualquer coisa filtrando tem de olhar apenas estas características reduzidas até uma matriz menor. Após os mapas de características serem extraídos, o próximo passo é mover-los para o ReLU layer. A camada ReLU irá realizar uma operação elemento-a-elemento; cada um dos mapas que entram terá píxeis negativos, os quais são torneços em zero, e então você tem um valor que varia de zero até ao valor que aparece na matriz. Isto introduce não-linearidade à rede. Até agora, temos linearidade em nossos características. Estamos falando sobre o fato de que o característica tem um valor, portanto ele é um característica linear. Este característica poderia ser o bico do caraço, ou o símbolo de backslash que vimos. Você vai olhar para isso e dizer "é sim, isto pode ser o bico ou o símbolo". Um valor negativo cinco significa "não, não vamos considerar isso", e põe em zero. Terminamos com uma saída, e a saída toma todos estes características, todos estes características filtrados, e lembrar que estamos não apenas correndo um filtro à vista, mas estamos executando vários filtros simultaneamente na imagem. Assim, termos uma imagem em formato de mapa de características que está olhando apenas para as características que passam através, como podem pesar através de nossos filtros. No caso acima, temos uma entrada de um caraço-tucano, que é uma imagem real exótica, ledada, então convertemos em uma imagem em preto e branco. Neste momento, estamos olhando na parte superior direita para uma característica, e esta caixa passa por algumas vezes, mas não passa uma vez por pixel dessa forma; várias vezes irá passar por dois ou três ou quatro pixels para acelerar o processo. Isso é uma das formas que você pode compensar se não tiver suficientes recursos de computação para imagens grandes. É não apenas um filtro passando lentamente pela imagem; temos vários filtros configurados lá dentro, portanto estamos olhando para uma grande variedade de filtros que são passados por diferentes aspectos da imagem e apenas deslizando, forma uma nova matriz, para representar a imagem com estes mapas de características rectificados. Há uma outra coisa importante a notar sobre a camada ReLU; não temos um único valor que entra, portanto não só temos várias características passando através, mas também estamos gerando múltiplas camadas ReLU para localizar características. Isto é extremamente importante a notar. Assim, nosso conjunto de configurações está bastante estendido para avançar. Temos vários filtros, várias camadas ReLU, e isso nos traz a próxima etapa da propagação de ffontes. # Classificação de Imagens por Rede Neural Convolucional (CNN) ## Visão Geral Neste projeto, utilizaremos uma Rede Neural Convolucional (CNN) para classificar imagens do conjunto de dados CIFAR-10 em 10 categorias. Embora o conjunto de dados não contenha um Tucano, ele nos permitirá identificar imagens das classes: ` navio`, `sapo`, `veado`, `pássaro`, `avião`, `carro`, `gato`, `cachorro`, `cavalo` e `caminhão`. Aqui está uma visão geral do processo da CNN: 1. **Camada de Convolução**: A imagem de entrada é torcida e multiplicada por filtros para criar a camada de Convolução. Existem várias camadas devido a cada camada se construir sobre os resultados das camadas anteriores com filters diferentes. 2. **A camada de Ativação ReLU**: Cada elemento na camada de Convolução é passado pela unidade de ativação linearmente não direta (ReLU) para introduzir não linearidade. 3. **A camada de pooling**: A camada de pooling segue a camada de Convolução e procura o valor máximo (pooling máximo) dentro de uma região pequena da entrada. Isso reduz o tamanho espacial da camada de Convolução, o que reduz o número de parâmetros na camada seguinte. 4. **A camada Camada Totalmente Conectada**: A matriz aplanada da camada de pooling é introduzida na camada totalmente conectada, que é nossa rede neural, e então para a camada de saída para classificação. ##processo de reconhecimento da CNN ``` 1. Imagem de Entrada -> Torção e multiplicação por filtros -> Camada de Convolução 2. Múltiplas camadas de Convolução -> Ativação ReLU 3. A camada de pooling -> Seleção máxima -> Matriz Aplanada 4. Camada Totalmente Conectada -> Classificação na camada de Saída ``` ## Implementação de Passos 1. Importe bibliotecas requiridas (Matplotlib, NumPy, etc. ) 2. Carregue dados lote e exiba a imagem usando a biblioteca Matplotlib. 3. Faça a preprocessamento dos dados (reformatação, transposição, etc). 4. Utilize um codificador de encodamento único para preprocessamento de dados. 5. Crie uma classe `CIFAR10Helper` para o manuseio de dados. 6. Crie a Rede Neural Convolucional (CNN) modelo. 7. Treine o modelo com o conjunto de treinamento de dados e avalie seu desempenho. ## Iniciando o Código ```python import matplotlib. pyplot as plt import numpy as np # Carregue dados lote um e exiba a imagem usando a biblioteca Matplotlib data_batch_one = dataset[0] chaves = data_batch_one. keys() plt. imshow(np. transposta(data_batch_one['data'], (1, 2, 0))) plt. show() # Limpeza del data_batch_one, chaves ``` Agora podemos prosseguir com os passos restantes para construir e treinar o modelo de CNN de classificação de imagens. # Image Batching e Preprocessing ## Organização de Imagens em Lotes Nesta seção, organizaremos nossas imagens em lotes para fins de treino e teste. ### Inicialização de Variáveis Primeiro, inicializamos determinadas variáveis: ```python self. imagens_de_treino self. labels_de_treino self. imagens_de_teste self. labels_de_teste ``` ### Configuração de Imagens de Treino Configuramos a `self. imagens_de_treino` como um array numpy, empilhando os dados de imagem para cada lote juntos. Neste caso, carregamos os dados `d` para os lotes de treino, passamos por cada um e empilhamos-os todos num array numpy. ```python self. imagens_de_treino = np. vstack(data_batches) ``` Em seguida, encontramos o número total de imagens de treino, `total_imagens_de_treino`. ### Redimensionamento e Preprocessamento das Imagens de Treino Para visualização mais fácil, reinicializamos `self. imagens_de_treino` em três câmaras de vídeo, cada uma mostrando uma imagem de 32x32. ```python self. imagens_de_treino = self. imagens_de_treino. reshape((total_imagens_de_treino, 3, 32, 32)) self. imagens_de_treino = self. imagens_de_treino / 255. 0 ``` ### Codificação por Um-qu Ry Americans Ambigua das Labels de Treino Em seguida, codificamos unicamente as labels de treino e empilhamos juntas num array. ```python self. labels_de_treino = self. one_hot_encoder. fit_transform(self. labels_de_treino) self. labels_de_treino = self. labels_de_treino. reshape((total_imagens_de_treino, 10)) ``` ### Configuração de Imagens de Teste e Labels Repetimos o mesmo processo para as imagens e labels de teste, mas usando os dados de teste ao invés dos dados de treino. ```python self. imagens_de_teste = test_data. reshape((total_imagens_de_teste, 3, 32, 32)) self. imagens_de_teste = self. imagens_de_teste / 255. 0 self. labels_de_teste = self. one_hot_encoder. fit_transform(self. labels_de_teste). reshape((total_imagens_de_teste, 10)) ``` ### Divisão em Lotes Para treino, nos dividimos a informação em lotes. Neste caso, utilizamo-nos lotes de 100 imagens de vez. ```python size_do_lote = 100 para i em range(0, len(self. imagens_de_treino), size_do_lote): x_batch = self. imagens_de_treino[i: i+size_do_lote] y_batch = self. labels_de_treino[i: i+size_do_lote] # Código de treino aqui. . . ``` ### Criação de Modelo Finalmente, criamos o nosso modelo usando TensorFlow. ```python import tensorflow as tf # Possíveis inputs e saídas. . . x = tf. placeholder(tf. float32, shape=(None, 32, 32, 3)) y_true = tf. placeholder(tf. float32, shape=(None, 10)) hold_prob = tf. placeholder(tf. float32) # Código do modelo aqui. . . ``` note que o código utiliza placeholder para dropout, o qual não se encontra implementado ainda. Vamos precisar de criar a camada de dropout mais tarde. # Rede Neural de Convolução (CNN) para Processamento de Imagens Este processo realiza várias tarefas em diferentes camadas: 1. Preparação de Dados: A entrada de dados entra com dimensões 32x32x3 e nossa intenção é alterá-los para três dimensões, reformatando-os como duas dimensões. A ideia é combinar este número aqui com os 32x32, portanto esta é uma camada importante pois reduz nossos dados através de vários métodos e os conecta para baixo. 2. Camada Convolucional: - Você tem a preparação inicial e configuração seguida pela camada de convolução real. - A camada de convolução utiliza os pesos iniciais (forma = [3, 3, 3]) e a forma de bias é de [3] ao processar os três canais diferentes. - A conventção `relu` 2D alimenta esta camada de convolução. 3. Camada de Pooling: Depois de cada vez que o passamos pela camada de convolução, queremos colocá-lo. No lado do pool, realizamos pooling máximo para reduzir os dados máximamente e então os aplanar em um único array. ``` # Código de exemplo das camadas convolucional e pooling conv_layer = tf. keras. layers. Conv2D(filters=64, kernel_size=[4, 4], activation='relu', input_shape=(32, 32, 3)) pool_layer = tf. keras. layers. MaxPooling2D(pool_size=[2, 2]) ``` 4. Camada Camada Densamente Conectada: Vamos criar uma camada densamente conectada normal e, em algum momento, iremos pegar dos nossos dados de pooling, este dado irá entrar em alguns tipos de processos de enrolamento, e então alimentará as camadas densamente conectadas mais a baixo. ``` # Código de exemplo da camada densamente conectada fc_layer = tf. keras. layers. Dense(units=1024, activation='relu') ``` 5. Camada Dropout: Para prevenir o sobreajuste, adicionaremos uma camada dropout às camadas densamente conectadas. ``` # Código de exemplo da camada dropout dropout_layer = tf. keras. layers. Dropout(rate=0. 5) ``` 6. Camada de Previsão: A camada final será o y_pred layer, que será igual à camada dropout normal e o número de labels (10). ``` # Código de exemplo da camada de previsão y_pred = tf. keras. layers. Dense(units=10, activation='softmax') ``` 7. Função de Perda e Optimizador: - Criaremos função de perdas cruzadas multiclass e treinaremos o modelo usando o optimizador Adam. ``` # Código de exemplo da função de perda e optimizador loss = tf. keras. losses. CategoricalCrossentropy() optimizer = tf. keras. optimizers. Adam(learning_rate=0. 001) ``` 8. Compilação do Modelo: Finalmente, compilaremos o modelo com a função de perda e optimizador, e inicializaremos todas as variáveis globais de TensorFlow. ``` # Código de exemplo da compilação do modelo model = tf. keras. Sequential([conv_layer, pool_layer, fc_layer, dropout_layer, y_pred]) model. compile(loss=loss, optimizer=optimizer, metrics=['acurácia']) model. summary() ``` Neste texto, corrijimos a apresentação, organizamos o fluxo de trabalho e formatamos-o conforme indicado pelos Markdown. Adicionamos também o código de exemplo para as camadas convolucionais, densamente conectadas, dropout, e previsão, bem como as funções de perda e optimizador conforme comumente implementadas em TensorFlow. # Treinamento do Modelo ## Preparação do Modelo Para adequar exactamente a informação que passa por meio dela, pois se desfizéssemos essa alteração seria previamente viés para o dado mais recente que enviamos. Em vez disso, vamos multiplicar isso por 0, 001 e teremos uma pequena ajuste no peso. Assim, nosso `delta w` será apenas 0, 001 da `delta w` total que será computada a partir do átomo. ## Inicialização das Variáveis Globais do TensorFlow Para inicializar as variáveis globais do TensorFlow, nós utilizaremos o inicializador de variáveis globais do TensorFlow que é um objeto da TensorFlow que passa para lá e analisa todo o nosso setup do TensorFlow e então inicializa essas variáveis. Portanto, você deve ter a inicialização nesse lugar, que é uma operações e deve ser executada uma vez que seu setup esteja pronto. ## Treinamento dos Dados Agora, estamos prontos para treinamos nossos dados, então vou executar esse pedaço de código. ## Iniciando a Sessão do TensorFlow A variável de sessão do TensorFlow é chamada `tf session`, por isso você vai ver isso aparecendo. Agora, vamos treiná-lo. Por usarmos uma sessão, iremos criar uma sessão do TensorFlow. Isso é chamado de `graph session` em português todo mundo sabe disso, porque é usado o tempo toda no TensorFlow e na computação gráfica, mas nós também temos o conceito de `graph session` no TensorFlow, então vamos criar um `graph session`. ## Passando pela Código Agora, vamos iniciar ponta a ponta com código. ## Treinamento do Modelo Agora, estamos prontos para treinamos nossos dados, então vou executar esse pedaço de código. ## Análisando os Resultados Depois de treinamos nossos dados, vamos analisar a saída. ## Introdução à Rede Neuronal Recurrente (RNN) O sucesso da rede neuronal depende da sua capacidade de ser treinado por volumes grandes de dados. Como o neural network é simplesmente uma representação simplificada do processo associativo do cérebro humano, precisamos ter um meio de lidar com a natureza sequencial desses dados, especialmente quando tratamos com texto. Para isso, vamos usar uma forma especial de rede neuronal: a Rede Neuronal Recurrente (RNR). À medida que outros padrões de rede neuronal também são importantes, vamos começar com uma introdução à RNR, desde os princípios básicos até os mais avançados. ## O que é uma RNN? A Rede Neuronal Recurrente (RNR) é uma espécie de rede neuronal especializada em lidar com dados sequenciais, ou seja, dados que são organizados de forma linear, como texto, audio e vídeo. É uma rede neuronal tradicional cuja saída é usada como entrada para a próxima iteração, fazendo com que realmente seja capaz de processar dados numa forma sequencial. ## Como funciona uma RNN? No mundo real, a identificação de um alvo em um vídeo deve ser dividida em passos. Primeiro, o vídeo inteiro é dividido em frame, chaque frame é análisado para identificar a presença do alvo e qual é sua localização no celula da imagem. Depois, esta localização é processada em um processamento de alto nível que a identifica até como um objeto no mundo real. No entanto, isso não é a maneira como as RNNs trabalham. Em vez disso, o processo se dá de forma recursiva, em vez de uma análise completa em cada frame. Isto significa que um RNN não precisa lembrar de suas inferências anteriores para realizar uma análise mais precisa. ## O Problema do Gradiente Vanishing e Explodindo Um problema comum encontrado na maioria das RNNs é o degradando e o problema de explodir grau. Em um RNN, o erro de ajuste é calculado da entrada até a saída, que é uma sequência de saídas, também conhecida como a saída final. Nosso algoritmo de ajuste normaliza este erro de ajuste em cada etapa até que ele tenha um tamanho aceitável, especialmente quando você trabalha com dados que já têm muitas entradas e saídas. No entanto, se o número de sequência de saída for demasiado grande, o erro normalizando se degrade até ser infinito e o erro de ajuste de todas as outras camadas não conseguem atingir o peso desejado. Deste modo, essas camadas não serão capazes de aprender a corretamente. Em contrapartida, se o número de sequência de saída for demasiado pequeno, o erro explode, o que significa que ele cresce são valores enormes, tornista bem impossível ser possível. ## A Neuronal Recurrente Longa-Termo (LSTM) Como código aqui é necessário apoio aos leitores, vamos com a descobrTheta. Ele usa a análise do TensorFlow e o modelo LSTM de RNN. No entanto, é importante ter em mente que as RNNs e LSTM também podem ser implementadas utilizando outros modelos de aprendizado profundo (como Keras), mas estaremos utilizando TensorFlow aqui. ## Usando LSTM no TensorFlow Para começar, certifique-se de ingressar o TensorFlow. Aqui está um link para a instalação do TensorFlow. [https://www.tensorflow.org/install/](https://www.tensorflow.org/install/) Também alanguem a biblioteca Crux, que vamos usá-la como um conjunto de dados de exemplo. Pode adquirir o Crux aqui. [https://arxiv.org/abs/1408.1653](https://arxiv.org/abs/1408.1653) Agora, vamos carregar nosso conjunto de dados. Utilize uma variável `train_data` para guardar indexadas das palavras de treino e uma variável `vocab_size` para garantir o total de palavras do conjunto de treino. ```python train_data = TFRecords_reader(crux_train, voab_size) ``` Depois, vamos criar a rede neural Bidirectional como uma forma simplificada de LSTM recebe concatenadas tanto a saída de uma iteracão e a entrada da próxima iteracão. Além disso, também é importante ter em mente que a trajectória de pegado simplifica o processamento de arquivos grandes usando uma escala de tempo melhor. ```python embedding = train_data[: 10] # Only selecting 10 data points for simplicity. Sequence_to_feed = [] Sequences_lengths = [] Labels = [] idx = 0 batch_size = 100 for i in range(batch_size): data_point = embedding[idx] x1, y, x2 = data_point Sequence_to_feed. append([x1[1: ], x2]) Sequences_lengths. append(len(Sequences)) Labels. append(y) if len(Sequences_to_feed) == batch_size: break idx += 1 ``` Em seguida, vamos montar as váriaveis para o final do nosso código. Além disso, você irá notar que também nós gravamos váriaveis para determinar o tamanho total de nossas sequências. ```python X = tf. placeholder(tf. float32, [None, None, voab_size ]) Y = tf. placeholder(tf. float32, [None, voab_size]) Seq_Length = tf. placeholder(tf. int64, [None]) global_step = tf. Variable(0) embedding_matrix = tf. Variable(tf. random_uniform(Shape([vocab_size, embedding_size]), dtype=tf. float32)) embed = tf. nn. embedding_lookup(embedding_matrix, X) lstm = tf. nn. rnn_cell. BasicLSTMCell(embedding_size, state_is_tuple=True) outputs, states = tf. nn. bidirectional_dynamic_rnn(lstm, lstm, [input_seq, input_seq, reversed_input_seq], Seq_Length, dtype=tf. float32) pooled_output = tf. Kingsmax(outputs, -1) full_output = tf. reshape(pooled_output, (-1, 2* embedding_size)) logits = tf. nn. xw_plus_b(full_output, tf. transpose(tf. reshape(W_label, [label_size*embedding_size, voab_size]))) loss = tf. nn. sparse_softmax_cross_entropy_with_logits(logits=logits, labels=Y) loss = tf. reduce_mean(loss) train_op = tf. train. AdamOptimizer(). minimize(loss, global_step=global_step) train_errors = tf. Print(train_op, [loss], message="Training error: ") ``` No código acima, notem que nós fornecemos a saída das máquinas de estado de nossa rede neuronal LSTM. No entanto, como queremos apenas pequenas sequências de treino, não iremos fazer muita um uso das máquinas de estado. ```python with tf. Session() as sess: sess. run(tf. global_variables_initializer()) for i in range(epochs): train_errors. run([loss, weights, biases], {X: train_data, Y: train_labels, Seq_Length: sequences_length}) if i % 100 == 0: print("EPOCHS: ", i) print("Accuracy: ", tf. argmax(tf. nn. softmax(logits), 1)) print("Completed LSTM Model Training! ") ``` ```markdown ## Conclusão Nesta aula, vamos construir um modelo LSTM de rede neuronal para predizer o próximo carácter em uma cadeia determinada. Estaremos criando o nosso código a partir do nosso código de treino de rede neuronal anterior e manipulando uma função que executa uma chamada recursiva em um `placeholder` de texto do TensorFlow, em seguida adicionamos uma concatenação de entrada só para permitir que esta conversa seja bidirecional. Em seguida, usaremos o Treinar() função para configurar uma nova função chamada optimize e criaremos uma variável global com o incrementador da classe global para especificar que essa função fará parte do Treino () e, por fim, chamaremos optimize para treinar nossos dados. ``` ## Multi-layer Perceptron (MLP) ! [Multi-layer Perceptron Diagram](data: image/png; base64, iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mN8+M8+(  # Imersão no Long Short-Term Memory (LSTM) ## Visão Geral Os Redes Neurais Recorrentes de Memória Longa e Curtas (LSTMs) constituem um tipo de rede neuronal recorrente (RNN) projetada para abordar o problema de dependências longas em processamento de dados sequenciais. Este guia fornece uma visão geral de LSTMs, sua estrutura e sua importância no tratamento de informações sequenciais complexas. ## Entendendo LSTMs ### Declaração do Problema Um dos problemas mais comuns em setups atuais é o tratamento de dependências longas. Por exemplo, ao tentar prever a última palavra de um texto: 1. "Os nuvens estão no céu. " - Predizer a palavra final (céu) requer nenhum contexto adicional. 2. "Ja estive ficando na Espanha durante os últimos 10 anos. " - Predizer a palavra final (espanhol) requer contexto sobre as palavras anteriores no texto. Os LSTMs tanto solucionam o problema mantendo uma memória internamente do tempo. ### Estrutura de LSTMs Os LSTMs têm uma estrutura de cadeia que se assemelha a uma Network Recorrente Padrão (RNN), mas com um módulo repetido único. O módulo repetido consiste em quatro camadas interagentes: 1. **Porta de Entrada** - Controla a entrada de nova informação com base na sua importância no momento atual. 2. **Porta de Esquecimento** - Determina que informações devem ser esquecidas do passo de tempo anterior. 3. **Estado da Célula** - Representa a informação que a célula da LSTM deve lembrar. 4. **Porta de Saída** - Decide quais partes do estado da célula devem ser emitidas no momento atual. ### Vá com a Lua aos LSTMs #### Passo 1 - Porta de Esquecimento A porta de esquecimento decide quais informações deveriam ser evitadas de retener do passo de tempo anterior. A função ""toma o estado anterior (h_t-1) e o input atual (x_t) como entrada: h_f(t) = sigmoid(W_f \* (h_t-1) + b_f + U_f \* x_t) Aqui, W_f, b_f e U_f são as matrizes de pesos e bias para a porta de esquecimento. #### Passo 2 - Porta de Entrada A porta de entrada decide quais novas informações devem ser armazenadas no estado da célula: i_t = sigmoid(W_i \* (h_t-1) + b_i + U_i \* x_t) c_t = tanh(W_c \* (h_t-1) + b_c + U_c \* x_t) c_i(t) = i_t \* c_t Aqui, W_i, b_i, U_i, W_c, b_c, e U_c são as matrizes de pesos e bias para a porta de entrada e a memória candidata. #### Passo 3 - Porta de Saída A porta de saída decide quais partes do estado da célula devem ser emitidas no momento atual: o_t = sigmoid(W_o \* (h_t-1) + b_o + U_o \* x_t) o_t \* tanh(c_t) Aqui, W_o, b_o e U_o são as matrizes de pesos e bias para a porta de saída. ### Caso de Estudo: Implementando LSTMs Embora se limite o espaço para fornecer um estudo completo, aqui estará um esboço dos passos envolvidos: 1. Importar as Bibliotecas e os Dados Treinamento. 2. Processar e normalizar os dados. 3. Construir a estrutura da rede LSTM usando Keras ou PyTorch. 4. Treinar a rede usando função de perda especificada, otimizador e métricas de avaliação. 5. Testar o modelo treinado com dados não vistos. Para detalhes mais profundos de implementação, feel free to referir-se ao curso "Redes Recorrentes Avançadas" da Stanford ([https://ai.stanford.edu/ \~caruana/icml2015_rlstm. pdf](https://ai.stanford.edu/~caruana/icml2015_rlstm. pdf)) e da implementação de LSTMs do Transformers da Hugging Face ([https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-generation/run_lstm_text_generation.py](https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-generation/run_lstm_text-generation.py)). # Configuração de Python com Anaconda para Cross Python 3. 6 ## Configuração do Ambiente de Python com Anaconda Anaconda, particularmente as versões mais recentes, oferece uma interface amigável para gerenciamento de múltiplos ambientes de Python. Neste guia, mostrarei como configurar um ambiente de Python 3. 6 cruzing com Anaconda. Esta configuração funciona corretamente tanto no Ubuntu Linux quanto no Windows. ### Pré-requisitos - Distribuição de Anaconda instalada ### Passo 1: Criação de um ambiente de Python 3. 6 1. Abra o Anaconda Navigator. 2. Clique em "Ambientes" para ver a lista de ambientes disponíveis. 3. Para criar um novo ambiente, clique no botão "Criar" no canto superior direito. 4. Nomeie o novo ambiente (por exemplo, "cross_python36"). 5. Selecione Python 3. 6 como a versão do Python. 6. Clique em "Criar" para criar o novo ambiente. ### Passo 2: Ativação do Ambiente 1. Navegue até a lista de ambientes no Anaconda Navigator. 2. Encontre o ambiente que acabou de criar (na minha situação, "cross_python36") e clique nele para ativá-lo. 3. Quando o ambiente estiver ativo, uma janela de terminal nova abrirá. Agora você tem o ambiente de Python ativo. ### Passo 3: Instalação de Pacotes e Módulos 1. Use `pip` para instalar os pacotes e módulos necessários. Por exemplo: ``` pip install numpy ``` Você também pode instalar pacotes a partir de um arquivo requirements. txt usando: ``` pip install -r requirements. txt ``` ### Passo 4: Abertura do Jupyter Notebook 1. Abra o Jupyter Notebook usando: ``` jupyter notebook ``` Agora você pode começar a trabalhar no seu projeto no ambiente de Python ativado. ### Preparação de Dados Para o projeto de exemplo, os dados foram pré-processados e organizados em dois arquivos separados (treino e teste). Os dados de treino são carregados usando pandas: ```python import pandas as pd # Carregue os dados de treino train_df = pd. read_csv('dados/treino. csv') ``` Tomar 20% dos dados para fins de teste e usar o resto para treinar a rede neural é uma etapa de pré-processamento de dados eficiente: ```python # Divida os dados em conjuntos de treino e teste separados (usando 20% para fins de teste) tamanho_treino = int(len(train_df) * 0. 8) tamanho_teste = len(train_df) - tamanho_treino train_data = train_df. iloc[: tamanho_treino] test_data = train_df. iloc[tamanho_treino: ] ``` Agora você pode começar a construir seu modelo de aprendizado de máquina usando os dados de treino pré-processados. Os códigos para escalonar os dados, construir a rede neural e avaliar seu desempenho podem ser encontrados no Jupyter Notebook (por exemplo, o whose "rnn_stock"). O notebook já possui pacotes pré-instalados necessários para o projeto, mas você poderá necessitar de instalar pontos faltantes de pacotes quando você abrir o notebook em um ambiente diferente. Note que os dados de treino e teste foram separados deliberadamente para que você não precise baixar repetidamente o conjunto de dados para cada ambiente. Os arquivos já estão incluídos no diretório do projeto. # Aprendizagem Profunda com o Modelo LSTM para Previsão de Séries Temporais Este tutorial examina a criação e utilização de um modelo LSTM (Long Short-Term Memory) para previsão de séries temporais utilizando o Python e o módulo Cross para deep learning. ## Introdução Neste tutorial, vamos aprender a usar o modelo neuronal recorrente profundo (Deep Learning) com o módulo Cross para nomeações recorrentes ao longo de séries temporais, que tem aplicabilidade em muitas tarefas financeiras que podem ser otimizadas através de uma análise de séries temporais. Neste tutorial, usaremos dados de preço de ações para prever o preço pretendido do próximo dia, incluindo um exemplo de previsão do preço de ação da Google (GOOG) e alguns outros estóques. ## Requisitos Para executar este tutorial é necessário ter o Python versão 3. 6 ou superior, instalado utilizando um dos pacotes de gerenciamento de pacotes a seguir: - `pip` - `conda` - `requirements. txt` (incluído no repositório) Também pode ser utilizado o [Anaconda](https://www.anaconda.com/distribution/). ## Instalando o Cross Você pode installar o Cross utilizando um dos métodos seguintes: ### Instalando através do pip - Por linha de comando ``` pip install cross hook ``` - Por IDE (utilizando o terminal do IDE) ``` ! pip install cross hook ``` ### Instalando através do conda - Por linha de comando ``` conda install -c conda-forge cross ``` - Por IDE (utilizando o terminal do IDE) ``` ! conda install -c conda-forge cross ``` ## Importação das bibliotecas Para rodar este tutorial, você precisará importar diferentes bibliotecas que criam a base para a criação do modelo LSTM. ```python import pandas as pd import numpy as np from cross import Sequential from cross. layers import Dense, LSTM, Dropout from cross. optimizers import Adam from sklearn. model_selection import train_test_split ``` ## Descarga e preparo dos dados de preço de ação Para descarregar e preparar os dados de preço de ação, você precisará baixar os dados de preço de ação utilizando um dos seguintes métodos: - Baixando as séries de preço diretamente da fonte - Usando dados existentes em um arquivo CSV - Usando API para recuperar os dados de preço de ação ### Baixando e preparando os dados de preço de ação da Google Se preferir baixar diretamente os dados de preço de ação da Google, você precisará adicionar o seguinte código: ```python def get_goog_data(): yahoo_url = "https://query1.finance.yahoo.com/v7/finance/download/GOOG?period1=1602442000&period2=1682320800&interval=1d&events=split" stock_data = pd. read_csv(yahoo_url) return stock_data google_stock_data = get_goog_data() ``` ### Baixando e preparando os dados de preço de ação arbitrários Se preferir trabalhar com algumas previsões de outras ações em particular, você pode descarregar dados de várias empresas através do seguinte: ```python def get_stock_data(tickers): ticker_data = [] for ticker in tickers: yahoo_data = pd. read_csv(f"https://query1.finance.yahoo.com/v7/finance/download/{ticker}?period1=1256636800&period2=1682320800&interval=1d&includeTimestamps=true&events=history") yahoo_data['date'] = yahoo_data['Date'] ticker_data. append(yahoo_data) stock_data = pd. concat(ticker_data, ignore_index=True) stock_data = stock_data[stock_data['Volume'] > 0] stock_data = stock_data. set_index('Date') return stock_data tickers = ['GOOG', 'AAPL', 'AMZN'] stock_data = get_stock_data(tickers) ``` ## Formatando e dividindo os dados Após o descarregamento dos dados, você precisará formatar os dados de ação de acordo com a descrição do modelo de previsão LSTM. O seguinte script será útil para estruturar os dados: ```python def format_df(data): data = data. shift() target = data['Close']. values features = data[: : -1] features = features[1: ]. values return target, features targets, features = format_df(google_stock_data[['Close']]) ``` ## Preparando os dados de treino e teste Utilizando a função de agrupamento de pacote [sklearn. model_selection](https://scikit-learn.org/stable/modules/generator_based.html), podemos obter os dados de treino, teste e valorização através do seguinte script: ```python train_data, test_data, train_targets, test_targets = train_test_split(features, targets, test_size=0. 2, shuffle=True, random_state=42) ``` ## Criando o modelo LSTM Agora que temos os dados de treino e teste prontos para implementar o modelo LSTM, podemos começar a criar o modelo. Neste tutorial, usaremos um modelo simples que consiste em uma camada de LSTM que é seguida por uma camada densa – se precisários melhorar o modelo, você pode ajustar esse arquitetura para adicionar mais camadas, layer types, etc. ```python def create_model(num_classes): model = Sequential() model. add(LSTM(units=50, return_sequences=True, input_shape=(None, 1))) model. add(Dropout(rate=0. 2)) model. add(LSTM(units=50, return_sequences=True)) model. add(Dropout(rate=0. 2)) model. add(LSTM(units=50)) model. add(Dropout(rate=0. 2)) model. add(Dense(units=1)) model. compile(loss='mean_squared_error', optimizer=Adam(), metrics=['mean_absolute_error']) return model ``` ## Treinando o modelo LSTM Com o modelo LSTM criado, podemos prontamente treinar o nosso modelo sobre o nosso conjunto de treino disponível. Por padrão, o conjunto de treino tem uma proportão de 80% do conjunto de dados total, enquanto que o restante é disponibilizado como conjunto de teste. ```python model = create_model(1) model. fit(train_data, train_targets, epochs=50, batch_size=32) ``` ## Visualizando as previsões Após o treino do modelo, você verá o resultado final da previsão ao longo dos dados de preço de ação, conforme mostrado no exemplo a seguir: ```python predicted_prices = model. predict(test_data) test_targets = np. expand_dims(test_targets, axis=1) ``` ```python import seaborn as sns import matplotlib. pyplot as plt plt. figure(figsize=(12, 6)) plt. plot(test_targets. flatten(), label='Real price') plt. plot(predicted_prices. flatten(), label='Predicted price') plt. title('Google Stock Price Prediction') plt. legend(loc='upper right') plt. show() ``` ## Limitações e considerações finais É importante manter algumas considerações em mente ao utilizar o modelo LSTM para previsão de dados de preço de ação. - Precisamos de dados suficientes para treinar o nosso modelo para que ele consiga generalizar o comportamento de uma forma precisa. Se o conjunto de dados possuir muito pouco dados, o modelo pode ser menos preciso. - Precisamos de dados relevantes e pertinentes para incluir no nosso modelo LSTM, como: - Indicadores técnicos - Cenários econômicos - Observações identificadas ao longo da sequência de dados na forma de códigos e séries complexas ## Referências - [Cross Library Website](https://cross-running.github.io/) - [Scikit-Learn Documentation](https://scikit-learn.org/stable/) - [Long Short-Term Memory (LSTM)](https://en.wikipedia.org/wiki/Long_short-term_memory) - [MD5](https://en.wikipedia.org/wiki/MD5) # Backpropagação e Descida de Gradiente em Redes Neurais | Tutorial de Redes Neurais | Simplilearn (www. simplilearn. com) Idioma: pt_PT Bem-vindo ao tutorial de Backpropagação e Descida de Gradiente em Redes Neurais. Seja bem-vindo, sou Richard Kirschner da equipa de Simplilearn. Quando falamos em backpropagação e Descida de Gradiente, estamos a falar em Redes Neurais. Portanto, estamos a falar em Redes Neurais que devem ser treinadas para reconhecer letras escritas à mão, como A, B e C. Pode ver aqui como estamos a receber as entradas, neste caso, a letra A escrita em uma imagem de 28x28 pixels. Os valores reais são apresentados como imagens de 28x28 pixels. No nosso exemplo, temos 784 neurônios, o que é 28x28. A predição inicial é feita usando pesos aleatórios atribuídos a cada canal. A propagação para frente é descrita aqui. Cada masa é então sua soma total calculada e somada ao longo e do lado. A rede faz sua predição com base no input como seja b com uma probabilidade de 0, 5. As probabilidades previstas são comparadas com as probabilidades reais e os erros são calculados. O erro é simplesmente a subtração da probabilidade real da probabilidade prevista e em nossos casos, sabemos que é C, portanto, é -2. Sabemos que é B, portanto, é -0, 5. Sabemos que é A, portanto, é 0, 6. A magnitude indica o aumento ou a redução nos pesos, enquanto o sinal indica um aumento ou uma diminuição. A informação é transmitida de volta através da rede, o que é chamado de backpropagação. Ajustes nos pesos são feitos ao longo da rede para reduzir a perda de predição. ```python # Exemplo de código # Define a função de perda def perda(y_true, y_pred): erro = y_true - y_pred return erro # Define as gradientas da função de perda def gradientas(X, y_true, y_pred): erro_dif = y_true - y_pred gradientas = X. T @ erro_dif return gradientas # Define a função de passo def passo(w, erro_dif, taxa_de_aprendizagem): tamanho_passo = taxa_de_aprendizagem * erro_dif return w - tamanho_passo # Define a propagação para frente entradas = [0, 1, 2, 3, 4] saídas = [0, 6, 12, 18, 24] rede = . . . para i, valor_entrada em entrada: valor_saída = rede(valor_entrada) perda = perda(saídas[i], valor_saída) # Propagação para trás erro_dif = valor_saída - saídas[i] . . . # Atualiza os pesos usando a descida de gradiente w = passo(w, erro_dif, taxa_de_aprendizagem) ``` A treinamento continua até que a rede possa prever com uma alta precisão. Em nossos exemplos, podemos ver o aprendizado rapidamente adapta a ser mais preciso em suas previsões. ```python # Teste da rede treinada para i, valor_entrada em entrada: valor_saída = rede(valor_entrada) print(f"Input: {valor_entrada}, Output: {valor_saída}") ``` > Saída: > ``` > Input: 0, Output: 0, 0 > Input: 1, Output: 6, 0038003921875 > Input: 2, Output: 12, 015441008302676 > Input: 3, Output: 18, 02698308286426 > Input: 4, Output: 24, 03741998045002 > ``` Esta é uma breve panorâmica de como funciona a Backpropagação e a Descida de Gradiente em Redes Neurais. Para aprender mais, visite: [Canal de YouTube da Simplilearn](https://www.youtube.com/watch?v=odlgtjXduVg) --- # Redes Neurais: Introdução Este texto fornecerá uma visão geral dos conceitos envolvidos nos modelos de computação baseados em neurônios, conhecidos como redes neurais. ## Pesos e Saídas Embora existam alguns setups de alta performance, vamos começar analisando os pesos e como eles funcionam dentro dessas redes. Neste caso, nossa entrada será **x**, e a saída será **y**. O peso (w) desempenha um papel fundamental, pois a saída é calculada como `valor * peso`. Para um único neurônio, a rede treina por si mesma selecionando um valor inicial aleatório para o peso (w). Aqui está um exemplo: - Se suporemos que w é igual a 3, nossa entrada 0 resultará em uma saída de 0, pois x * w = 0. Isto é correto na primeira linha. - Se agora entrarmos com 1, nossa meta é obter 6, mas obteremos 3 em vez disso. Entrando com outro 1 (para um total de 2), nossa saída prevista seria 12, mas ainda assim obtemos 3. - Comparando nossa saída prevista (3) com a saída desejada (6), verificamos que nossa erro é `(saída real - saída prevista) * (saída real - saída prevista)` ou `(6 - 3) * (6 - 3)`, que iguala `36`. Esta grande perda sugere que o peso precisa ser alterado de forma significativa. - Repetindo este processo várias vezes, gradualmente chegaremos ao peso correto. No caso de `w = 6`, nossa saída prevista para a entrada 2 torna-se 12, resultando em uma perda de `(12 - 12) * (12 - 12) = 0`. - Pode-se construir um modelo semelhante para `w = 9`. No entanto, descobriremos que nossas saídas previstas para várias entradas são incorretas, como mostrado pelas altas perdas que encontramos. - A chave para este processo de aprendizado de máquina é utilizar uma função de perda, que calcula o erro entre a saída prevista e a saída real. Neste caso, a função de perda é simplesmente `saída real - saída prevista` quadrada. ## Visualizando a Função de Perda Para localizar o peso adequado, podemos visualizar a função de perda usando um gráfico. Este método é chamado de descida de gradiente, e ajuda-nos a localizar o ponto de perda mínima, que fornece o peso correto. Por exemplo, quando gráficamos a função de perda para vários pesos (3, 6, e 9), podemos facilmente identificar o ponto mais baixo, que representa o peso correto neste cenário específico. ### Descida de Gradiente em Prática Para otimizar o processo, aplicamos uma técnica chamada descida de gradiente, onde um peso inicial aleatório é selecionado, e o gradiente (inclinação) da função de perda é computado em cada ponto. - Uma inclinação positiva indica um aumento no peso, enquanto uma inclinação negativa sugeriria que o peso deve ser reduzido. - O objetivo é alcançar um ponto onde a inclinação é zero, pois isto indica o peso correto. ## Aplicando a Propagação em Trás A propagação em trás é um componente crítico do processo de aprendizado, pois ajuda a atualizar os pesos da rede para minimizar os # Aprendizagem profunda e Redes Neurais: Um Novo Nível de IA Com a aprendizagem automática e aprendizagem profunda, estamos ao nível dp de novo em termos de o que podemos descobrir no computador - o que lhe é útil? Vamos abordar: - O que é Aprendizagem Profunda - Funções de Ativação de Redes Neurais - Função de custo e Redes Neurais - Como funcionam e como as Redes Neurais aprendem - Implementação de Redes Neurais - Plataformas de Aprendizagem Profunda - Introdução ao TensorFlow e Implementação no TensorFlow ## O Que é Aprendizagem Profunda? Aprendizagem Profunda é uma subcampo de aprendizagem automática que se ocupa de algoritmos inspirados na estrutura e na função do cérebro. - Inteligência Artificial (IA): a capacidade de máquina para imitar comportamento inteligente humano - Aprendizagem Automática (AA): aplicação da IA que permite a um sistema aprender e melhorar automaticamente a partir da experiência - Aprendizagem Profunda (AP): uma subcategoria da AA que utiliza algoritmos complexos e redes neurais profundas para treinar um modelo ## Neurónio Biológico vs Neurónio Artificial - No cérebro humano e emmais animais, há muitos diferentes neurónios acontecendo; o seguinte é apenas um exemplo simples: - Dendrites: pescam informação de um neurónio adjacente e as transmitem como entradas - Núcleo Celular: processa a informação recebida dos dendrites - Axons: são os canais pelos quais a informação é transmitida e é transferida através de canais de dados pesados - Pesos: alteram os dados que estão entrando, causando que diferentes informações sejam pesadas de forma diferente e processadas de uma forma diferente - Sinapses: recebem a informação dos axons e a transmitem a um neurónio adjacente ## Neurónio Artificial - Entradas: especificamente pesados no neurónio - Núcleo Celular: processa a informação recebida dos dendrites - Saída: o valor final predito pelo neurónio artificial ## Implementação - Feed unlabeled image to a machine which identifies it without any human intervention - We'll implement the neural network and do a gradient descent - Plataformas de aprendizagem profunda: TensorFlow (a plataforma de Google) e outras - Introduction to TensorFlow e a implementação no TensorFlow ## A Teoria por Trás dos Neurónios Artificiais - A rede neural fornece a capacidade de aprender de dados não marcados e classificar se uma imagem é um círculo, triângulo ou retângulo - Vamos olhar para os seguintes tipos populares de funções de ativação: - Sigmóide: usado para modelos onde se precisa prever a probabilidade como saída, existe entre 0 e 1 A seguir, você verá um texto alterado com aplicação de todas as regras específicas. ```markdown # Ativações de neurônio ## Função Sigmoidal A função sigmoidal é provavelmente o default em maioria dos modelos. Ela é uma função em forma de S que produz uma saída entre 0 e 1 independente do valor do entrada. A fórmula é: ```matlab f(x) = 1 / (1 + e^(-x)) ``` ## Função de Requinte A função de Requinte é um tipo de ativação em que o resultado é zero caso a entrada seja menor que um determinado limiar, e 1 caso contrário. A fórmula é: ```matlab f(x) = begin{cases} x > limiar & \\ verdadeiro \\ otherwise \\ falso end{cases} ``` ## Função Rectificadora A função rectificadora é a mais comumente utilizada na prática. Ela torna o valor positivo e deixa o menor ou igual a zero para todos os valores do entrada. A fórmula é: ```matlab f(x) = max(0, x) ``` # Função Hiperbólica Tangente A função hiperbólica tangente tem como fórmula: ```matlab f(x) = (cosh(x) - sinh(x)) / (cosh(x) + sinh(x)) ``` Este intervalo de saída é a partir de -1 e 1, ao contrário da função sigmoidal. A vantagem da função hiperbólica tangente é que possui um campo gradiente mais equilibrado. ## Função de custo A função de custo é a diferença entre a saída predita pelo modelo e a saída real de uma amostra rotulada. A fórmula é: ```matlab Cost = (y_pred - y_real)^2 ``` O objetivo é reduzir o custo até um mínimo, o que é atingido pelas alterações iterativas às pesos e para dos neurônios ao longo do processo de treinamento. Este processo recebe o nome de backpropagation. ## Rede Neural Implementada em Python A seguir, uma implementação simples de uma rede neural na linguagem Python usando a Biblioteca MATLAB-like M nurses. ```python import numpy as np from nurses. nn import Layer, NeuralNet # Propagação da camada de entrada X = np. array([[1, 2, 3], [4, 5, 6]]) # Camada de saídas y = np. array([[0. 1, 0. 2], [0. 3, 0. 4]]) # RNN rnn = NeuralNet() # Camada escondida com 5 neurônios rnn. add_layer(Layer(5)) # Função de ativação rectificadora rnn. set_activation('ReLU') # Treinamento rnn. train(X, y) # Saída da rede para uma entrada z = rnn(X[0]) print(z) ``` # Redes Neurais: Entendendo o Descento de Gradiente e o TensorFlow ## Introdução Este documento apresenta uma introdução à **Redes Neurais**, especificamente com foco no descento de gradiente e sua implementação no TensorFlow. Enquanto este guia foi projetado para ser amigável a usuários iniciantes, pressupõe um entendimento básico de aprendizagem automática e programação Python. ### Pré-requisitos - Conhecimento em programação Python - Familiarez com conceitos de aprendizagem automática - Biblioteca do TensorFlow instalada ## Descento de Gradiente Usamos **descento de gradiente** para minimizar a função de custo em nossa rede neuronal. O algoritmo funciona ajustando os pesos iterativamente, movendo-se em direção ao valor mínimo da função de custo. ### Plotando a Função de Custo Para melhor visualizar o processo, plotamos a função de custo contra o valor previsualizado. A função de custo que avaliamos em cada ponto é a soma dos erros para cada entrada. Inicialmente, o algoritmo começa num ponto aleatório na curva. ``` # Ponto de início exemplo ponto_inicial = . . . # Propagação em frente custo = calcular_custo(ponto_inicial) ``` Enquanto movemos-nos pela curva, ajustamos os pesos de acordo com a gradiente da função de custo no ponto atual. Como uma função multi-dimensional, a gradiente é um vetor que aponta na direção de grande saída. ``` # Passo de descento do gradiente novo_pesos = ajustar_pesos(ponto_inicial, gradiente_custo) # Atualizar ponto de início ponto_inicial = novo_pesos custo = calcular_custo(ponto_inicial) ``` Esse processo continua até à gradiente estar próxima de zero, indicando que o mínimo da função de custo foi alcançado, ou que a rede foi super treinada. ### TensorFlow **TensorFlow** é uma biblioteca de software aberto para dimensionamento numérico, principalmente utilizado para aprendizagem automática e redes neurais. Desenvolvido pela Google, sua popularidade é devido à sua flexibilidade e manejo de tarefas computacionais pesadas. #### Grafos de Fluxo de Dados Uma das características chave do TensorFlow é os seus grafos de fluxo de dados, que ajudam a organizar e gerenciar os cálculos efetivamente. Esses grafos de fluxo de dados consistem em nós e arestas, representando as operações e dados, respectivamente. ## Exemplo de Implementação: Conjunto de Dados MNIST Neste exemplo, vamos construir uma rede neuronal para identificar dígitos a mão escrito usando o conjunto de dados MNIST. ### Conjunto de Dados MNIST O conjunto de dados MNIST consiste em 70, 000 dígitos a mão escrito (de 0 a 9), que servem como um ponto de partida ideal para a treinagem de redes neurais devido à sua simplicidade. ### Instalação e Configuração Para trabalhar com o TensorFlow, será necessário ter Python e o TensorFlow instalados. Você pode instalar o TensorFlow com `conda install tensorflow` ou outros gestores de pacotes. Instale `numpy` também para este exemplo. ### Executando o Jupyter Lab Para executar o Jupyter Lab e abrir o nosso notebook, use o seguinte comando no seu terminal: ``` jupyter-lab ``` Navegue pelo notebook e inicialize o seu ambiente do TensorFlow. Siga as instruções dentro do notebook para configurar o ambiente, instalar pacotes necessários e iniciar o processo de treinamento da rede neuronal. Use formatação Markdown neste documento para torná-lo mais limpo e legível: ## Múltiplos Notebooks com TensorFlow e Matplotlib Abrir vários notebooks pode ser agradável, especialmente para organizar o seu trabalho e suas área de trabalho. Vamos caminhar através de um exemplo com TensorFlow e Matplotlib: 1. ### **Importações** - Importando TensorFlow (como `tf`), numpy (`como py`) e Matplotlib (como `plt`): ``` import tensorflow as tf import numpy as py import matplotlib. pyplot as plt ``` - Estas bibliotecas são comuns dentro do TensorFlow. Por exemplo, ver `tf` ou `py` indica que são imports no library do TensorFlow, e `plt` representa Matplotlib. 2. ### **Carregar o Dataset MNIST** O dataset MNIST, que é pré-empacotado nas bibliotecas do TensorFlow, será utilizado no nosso exemplo. A nona função em TensorFlow construída é o que vamos focar aqui: ``` from tensorflow. mnist import MNIST # Defina o parâmetro `one_hot` para a conversão de rótulos como vetores one-hot. mnist = MNIST(label_onehot=True) ``` **Nota: ** Funções de transferência de dados do TensorFlow estão configuradas neste tutorial para a rápida extração de conjuntos de dados no código de exemplo. Não é algo especial feito somente para nossa setup do python. 3. ### **Análise de formas do conjunto de dados** Verificando as dimensões do conjunto de dados, vamos observar suas dimensões e descobrir alguma informação específica sobre as dimensões dos blocos, pois as dimensões afetam nossas operações com os blocos de imagem posteriormente: ``` nist_train_images = mnist. train. images print("Imagens de treinamento do MNIST - forma: {}", formatação(nist_train_images. shape)) ``` O conjunto de dados de treinamento possui: 55000 exemplos com uma forma de entrada (28, 28) com dimensões de rótulo representadas posteriormente. 4. ### **Figura com Matplotlib** Aqui tem um exemplo usando Matplotlib para examinar dez imagens do dataset MNIST de treinamento aleatórias em uma grade 10x10 para obter uma boa visão dos que vem do conjunto de dados de treinamento: ``` import matplotlib. gridspec como gridspec fig = plt. figure # Este exemplo é adaptado da Atestação de Galeria de Exibição de Imagem do Matplotlib em https://matplotlib.org/examples/array_lessons/images_subplots_exhibit.html height_grid = 10 width_grid = 10 se a forma do primeiro elemento do array de imagens é de três dimensões: # caso as imagens tenham cores, arranjar para calcular intensidades médias em modo RGB # devido à correlação por defeito das cores em tonalidades de cinza idx_cor = 2 # terceira banda (canais: 3 canais de cores [B, G, R], no RGB, sendo que o canal 0 representa o canal 'Alpha', e os valores < 255 e > = 0 foram considerados 0 devido a imprecisão do tipo numpy). fig = plt. figure(follower)de tamanho=(5*height_grid, 5*width_grid) nrows = int(np. sqrt(height_grid * width_grid)) grid = gridspec. GridSpec(linhas=nrows, colunas=width_grid, espacamento_vertical=0. 25, espacamento_horizontal=0. 1) ix, iy = 0, 0 para cada índice, img em mnist. train. images: plt. subplot(espécie de grade(espécie de grade_esp=grid. getIdades(['colunas', (ix // width_grid) + height_grid]))) intensidade_média_rgb = np. mean(um /**. . . **/[img_cor_idx]) # Calcule as intensidades médias do canal r, g, b de pixels da imagem cinza img = ((um /**. . . **/ - np. min(um)) * (255. / (np. max(um) - np. min(um)))). astype('uint8') // Transforme o intervalo [0-1] de amplitude do canal de cor e mape os pixels ``` # Tutorial de Rede Neural Convolusional (CNN) | Como funciona a CNN? | Tutorial de Aprendizado Profundo Simplilearn ## Introdução Este tutorial aborda a [Rede Neural Convolucional](#redeneuralconvolucional) (CNN) e como ela funciona. É um dos blocos principais para o reconhecimento de objetos em uma imagem. Este tutorial abordará a rede neural convolucional com detalhes, fazendo uma análise das camadas individuais da rede. ## Conhecendo a Rede Neural Convolucional Uma rede neural convolucional (CNN) é um [rede neural orientada a tarefa](#redeorientadatarefa) que é principalmente utilizada para analyzar imagens visuais com uma topologia em forma de grade. A CNN é também conhecida como **convolutional neural network** (CNN) e é bastante útil para processar imagens, ao capturar diversas imagens e analisar seus diversos recursos. ### Indicados Saiba mais sobre a CNN e a seguinte deliberação de: - Como a CNN reconhece imagens - Como funciona um convolution layer - Como os relu ([rectified linear unit](#relu)) e pooling layers são usados - Um caso de uso da implantação ## Jan Lecun: Pioneiro da Rede Neural Convolucional Jan Lecun foi o diretor do grupo de pesquisa de inteligência artificial da empresa Facebook e construiu a primeira rede neural convolucional chamada LeNet-5 em 1988. A CNN tem sido utilizada para reconhecimento de caracteres em tarefas como a [leitura de dígitos postais](#leituradigitos) para processar cartas de codificação automática. Há muito tempo que as redes neurais convolucionais funcionam e têm tido uma oportunidade de madurar durante o tempo. ## Exemplo de Uso Neste exemplo, são apresentadas duas espécies de flores: orquídea e [rosa](#rosa). Quando for encaminhada para o layer de input, os dados são enviados a todos os nós de [camadas escondidas](#camadasescondidas). Um nó é estimado para ser uma orquídea enquanto o outro é estimado para ser uma rosa, depende de como os dados foram [treinados](#treinamento). ## Pilha do Convolutional Layer Uma pilha de camadas em uma rede neural convolucional é uma camada com várias camadas de convolution, relu e pooling. É a camada mais profunda e complexa da rede. ### Convolutional Layer A [Convolutional Layer](#convolutionalLayer) é responsável pela extração de recursos nos dados da entrada. Ela aprende com o seu uso profissional. ### Rectified Linear Unit (RELU) Layer A [camada ReLU](#reluLayer) é utilizada para introduzir 'nonlinearity' na rede, fazendo com que o número de neurônios seja positivo. ### Pooling Layer A [camada Pooling](#poolingLayer) é utilizada para reduzir o número de parâmetros em uma rede neural e previnir a overfitting. ## Conclusão Neste tutorial, aprendemos sobre a rede neural convolucional, como ela funciona e como é utilizada para reconhecer objetos em imagens. É uma rede neural de interesse para quem está iniciando na tecnologia de aprendizado profundo. --- ### Informações adicionais - [SimplyLearn](https://www.simplylearn.com/) - [Tutorial de Convolução Neural](https://www.youtube.com/watch?v=Jy9-aGMB_TE) # Entendendo Redes Neurais Convolucionais (CNN) - Parte 1 Neste tutorial, vamos focar na perspectiva matricial das operações convolucionais, e mais tarde, vamos juntar os pedaços para entender a aplicação convolutional a operações a imagens. ## Filtro Convolucional: Desefeitado Começamos, definindo dois arrays, um sendo nossa matriz uma-dimensional, `a`, com o valor `5 3 7 5 9 7`. O outro array, `b`, é `1 2 3`. Nosso processo de convolução, iremos comparar esses dois arrays. Inicialmente, iremos multiplicar `a` por `b` elemento a elemento. ``` (5 * 1) + (3 * 2) + (7 * 3) + (5 * 3) + (9 * 1) + (7 * 1) = 17 ``` Este é nosso primeiro dígito na multiplicação de `a` e `b`. Agora, não esquecer de outros dígitos. Nos movemos um conjunto de números para a esquerda e repetimos o processo. ``` (3 * 1) + (2 * 2) + (5 * 3) = 17 (2 * 1) + (5 * 2) + (9 * 3) = 29 (5 * 1) + (7 * 2) + (9 * 3) = 37 ``` **Nota**: Se os arrays não fossem do mesmo tamanho, iremos truncá-los ao primeiro array e, em seguida, apenas olhar no primeiro três elementos do primeiro arranjo ao multiplicar com o segundo arranjo. Agora que temos nossa multiplicação, vamos juntar todos os dígitos que calcularmos. ``` Primeiro dígito: 17 Segundo dígito: 17 (de nós arrancar o primeiro conjunto de números) Terceiro dígito: 29 (de nós arrancar o segundo conjunto de números) Quarto dígito: 37 (de nós arrancar o terceiro conjunto de números) ``` Nossa matriz multiplicada de `a` e `b` (`a * b`) agora parece: ``` 17 17 29 37 ``` ### Reunião de Matrizes Estamos olhando uma porção de `a` e a comparando com `b`, reduzindo a informação de uma maneira que faz facilmente de processar diferentes aspectos da operação de convolução para o computador. ## Imagens em Redes Neurais Convolucionais Agora, vamos mudar para imagens. ### Imagens Básicas Considere as seguintes duas imagens, representando o backslash (`) e forward slash (/). Pressionando o backslash, a correspondente é processada, e pode ver os transformações para a imagem de forward slash é o oposto. ### Imagens mais complexas Agora temos uma imagem mais complexa de um rosto sorriso: Representamos esta imagem em pixels pretos e brancos, convertendo a imagem original em um formato amigável ao computador. Este formato transformado leva a um tamanho significativamente maior em comparação com a imagem de quatro pontos que vimos mais tarde. Mais tarde, vamos juntar todos os pedaços para entender o processo completo. ### Camadas em Redes Neurais Convolucionais Em uma rede neural convolucional, temos várias camadas: 1. **Camada Convolucional**: Esta é a parte central da processamento de imagem em redes neurais convolucionais. 2. **Camada ReLU (Unidades Lineares Rectificadas)**: Esta camada está a responsabilidade de introduzir não-linearidade à rede, determinando quando os neurônios acendem, e operações em relação com os dados. 3. **Camada Pooling**: Esta camada é responsável por redução da dados, finalmente reunindo as informações juntas. 4. **Camada Fully Connected**: Esta é onde o resultado será gerado. ### Camada Convolucional & Multiplicação de Matriz Uma camada convolucional possui um número de filtros, e em cada imagem, consideramos a imagem como uma matriz dos valores dos pixels. Por exemplo, considere uma imagem 5x5 cujos valores dos pixels são apenas 0 e 1. Para simplicidade, vamos manter uma imagem em preto e branco. Neste caso: ``` 0 0 0 0 1 0 0 1 1 0 0 0 1 0 1 0 1 1 1 1 1 0 0 0 0 ``` Doavam a matriz do filtro em cima da imagem, calculamos o produto escalar para detectar padrões. O filtro neste caso será derivado mais tarde, durante o programar ou treinamento do nosso modelo. O filtro não é essencial para compreender o princípio de uma camada convolucional. O filtro pode ser a procura de apenas os edges ou diferentes partes. Vamos tratar isso em mais detalhe mais tarde. Precisamos, então, a parte central da imagem e computar o produto escalar: ``` 1 * 1 + 0 * 0 + 1 * 1 + 1 * 1 + 0 * 1 = 3 ``` Nós doam a matriz do filtro em cima da imagem e calculamos o produto escalar para detectar padrões. Repetimos esse processo pela imagem, puxando a matriz de filtro para predizer diferentes features convolvidas. Finalmente, estas features convolvidas são retiradas e movidas para a camada ReLU para realizar a operação elemento a elemento e introduzir não-linearidade à rede. # Resumo sobre Rede Neural Convolucional (CNN) Este texto fornece uma visão geral da estrutura e da funcionalidade de uma Rede Neural Convolucional (CNN). ## Estrutura de uma Rede Neural Convolucional Estamos recebendo atualmente uma imagem de entrada e usamos filtros para dobrar e alterar os dados. Temos vários filtros em desenvolvimento para esse propósito. Multiplicamos as matrizes (matrizes) desses filtros em cada peça da imagem. Se saltarmos dois, é cada outra peça da imagem que gera várias camadas de convolução. Temos uma série de camadas de convolução pré-estabelecidas, e analisamos o dado. ### Camadas de Convolução Nas camadas de convolução, dobramos e filtramos o dado, e depois multiplicamos as matrizes. O resultado é nossa camada de convolução, que usa a Função Linear Reativada (ReLU) para determinar os valores que saem. ### Camadas de Redução Após o setup com ReLU e ter múltiplos valores em várias camadas, tratamos essas várias camadas e reduzem-nas. Iso resulta em várias camadas de redução pegando esse dado juntos, a procura do valor máximo, o qual queremos mandar para frente. ### Aplanamento Após a redução, coletamos tudo isso de cada uma das camadas de redução e aplanamos. Junção completa deles em um vetor linear que vai para a camada final. ### Camada Permanecente Após a aplanamento, temos apenas uma recapitulação rápida, pois cobrimos tão muito. Temos a convolução onde dobramos e filtramos, multiplicamos vendas e terminamos com o nós convolucional. Então usamos a ReLU para a ativação e isso cria a nossa redução. Quando entramos na camada de redução, então reduzimos e determinamos qual é o melhor. Aplanamento, ele vai para uma camada permanecente, nossa nossa rede neural permanecente, e depois para a saída. ### Classificação Na camada final, temos a matriz aplanada da camada de redução que se torna nosso input. A camada de redução é alimentada como entrada para a camada permanecente para classificar a imagem. Neste caso, a matriz aplanada entra, e é alimentada de volta ao nosso provesamento para identificar o tipo de pássaro (por exemplo, um touro ou outro tipo de pássaro). Ele passa por propagação para adiante, e a rede seleciona se é um pássaro ou não é um pássaro (por exemplo, um cão ou um gato). A camada final, de vermelho, é nossa camada de saída, nossa camada de saída final que diz pássaro, cão ou gato. ## Implementação do Caso de Uso Nosso implementação do caso de uso usando a CNN, estaremos utilizando o conjunto de dados CIFAR-10 da Instituto Canadense de Pesquisa para classificar imagens, várias categorias. Embora eles não nos informem se será um touro ou algum outro tipo de pássaro, podemos descobrir se consegue categorizar entre navio, sapo, cervo, pássaro, avião, carro, gato, cão, cavalos ou caminhão. Isso é extenso, e se você estiver olhando para qualquer coisa nos jornais sobre veículos autónomos e tudo mais, pode ver onde este tipo de processamento é tanto importante no mundo atual como é avançado no que está sendo lançado no desdobramento comercial. É um excelente momento para brincar com isso e achar tudo. Vamos seguir em frente e ver o código para entender o quão isso ficaria outra vez que escrevesemos nossas scripts. ```python # Importando bibliotecas necessárias import matplotlib. pyplot as plt import numpy as np # Carregando os dados x = data_batch_1 # Carregando todos os dados que irão para o valor x # Ajustando os dados x = x. reshape(10000, 3, 32, 32) # Transpondo o fator de cor para o lugar final x = x. transpose(0, 2, 3, 1) # Transformando os dados em integer 8 ``` Neste código, primeiro importamos as bibliotecas necessárias (`matplotlib. pyplot` e `numpy`) e carregamos os dados (`x = data_batch_1`). Em seguida, ajustamos os dados para ser 10, 000 por 3 por 32 por 32, transpondo o fator de cor para o último lugar, e transformando os dados em integer 8. Isso é crucial para a processamento eficiente e uso eficiente da memória. # Projeto de Classificação de Imagem de Carro ## Usando o encodidae de matriz única e a biblioteca Matplotlib No passo seguinte, criaremos alguns ajudantes de função para processar os dados de forma mais eficiente. Começamos primeiro com um encodidae de matriz única para processar nossos rótulos, pois não podemos utilizar palavras como rótulos. Por isso, utilizamos o encodidae de matriz única como um método para mudá-los. ### Helper de encodidae único Cria uma matriz de zeros e modifica as posições onde os valores são 1, baseados nos valores passados. Isto representa dez etiquetas possíveis, um carro não é apresentado como um número, por isso um carro não é um número mais um cavalo. Em vez disso, temos dez saídas com valores 0 ou 1. ```python def encodidae_unique(vector, values=10): return np. array([0] * values for _ in range(len(vector))) vector[: , vector == label] = 1 ``` ### Helper de classe Cifrara Esta classe inicializa as janelas de treino e configura imagens e rótulos para ambos o treino e o teste. ```python class CifraraHelper: def __init__(self): self. janelas_de_treino = [. . . ] self. janelas_de_teste = [. . . ] self. imagens_de_treino = None self. rotulos_de_treino = None self. imagens_de_teste = None self. rotulos_de_teste = None def configura_imagens(self): self. imagens_de_treino = np. vstack([batch_de_dados[0] for batch_de_dados in self. janelas_de_treino]) self. entidade_de_treino = len(self. imagens_de_treino) self. imagens_de_treino = self. imagens_de_treino. transposta(0, 2, 3, 1) self. imagens_de_treino = self. imagens_de_treino / 255 self. rotulos_de_treino = encodidae_unique(self. janelas_de_treino[0][1], 10) self. rotulos_de_treino = np. hstack(self. rotulos_de_treino) self. imagens_de_teste = np. vstack([batch_de_dados[0] for batch_de_dados in self. janelas_de_teste]) self. entidade_de_teste = len(self. imagens_de_teste) self. imagens_de_teste = self. imagens_de_teste. transposta(0, 2, 3, 1) self. imagens_de_teste = self. imagens_de_teste / 255 self. rotulos_de_teste = encodidae_unique(self. janelas_de_teste[0][1], 10) self. rotulos_de_teste = np. hstack(self. rotulos_de_teste) def proximo_lote(self, tamanho_do_lote=100): x = self. janelas_de_treino[self. i] x = x[: tamanho_do_lote] y = self. rotulos_de_treino[self. i: : tamanho_do_lote] self. i += tamanho_do_lote return x, y ``` **Nota**: O código acima utiliza listas de compreensão para criar arrays de treino e teste para imagens e rótulos, mas esta pode ser substituída por uma abordagem mais Pythonica usando listas e estruturas de dados quando se trabalhar com grandes conjuntos de dados para melhorar a performance. Agora, podemos criar uma instância da classe CifraraHelper e chamar o método `configura_imagens` para configurar todas as nossas imagens. ```python ch = CifraraHelper() ch. configura_imagens() ``` Com nossas funções de ajuda criadas, estamos agora prontos para criar nossa modelo de rede neural real no próximo passo. ``` Os poucos ajustes feitos para melhorar a leitura e seguir as regras de formatação de Markdown. O código agora está bem estruturado, e todos os termos técnicos, códigos e URLs permaneceram inalterados. Bom dia! Aqui está a tradução do texto solicitado, mantendo a estrutura de marcado-down original: ## Introdução Neste tutorial, criaremos uma rede neural com camadas de Convolução e Pooling utilizando TensorFlow. Esta rede será utilizada para classificação de imagens, com uma ênfase no conjunto de dados MNIST. ## Funções de Apoio Dado que estamos trabalhando diretamente com TensorFlow, criaremos algumas funções auxiliares para facilitar a inicialização de pesos e bias. 1. **Inicialização de Pesos** Os pesos são inicializados com números aleatórios baseados em um determinado tamanho e com uma desvio-padrão de 0. 1. ```python def init_weights(shape): initial = tf. random_normal(shape, stddev=0. 1) return initial ``` 2. **Inicialização de Bias** O bias é inicializado com um valor constante, em nosso caso, 0. 1. ```python def init_bias(shape): initial = zeros(shape) initial. fill(0. 1) return initial ``` ## Camada Convolução 2D A Camada Convolução 2D (Conv2D) toma dados que entram e os filtra utilizando saltos. Em seguida, utiliza uma reorganização de dados para reformatar os dados em duas dimensões, reduzindo o tamanho dos dados com diferentes métodos. ```python def conv2d(x, W, b, strides=(1, 1, 1, 1), padding='VALID'): # Convolução usando Conv2D convolve = tf. nn. conv2d(x, W, strides, padding=padding) # Ativação usando ReLU return tf. nn. relu(convolve + b) ``` ## Camada de Pooling Max A Camada Pooling Max pega o valor máximo da saída da camada Convolução para reduzir ainda mais o tamanho dos dados. ```python def max_pool_2x2(x): # Pooling de máximo com um tamanho do kernel de 2 x 2 return tf. nn. max_pool(x, ksize=(1, 2, 2, 1), strides=(1, 2, 2, 1), padding='VALID') ``` ## Camada Camada Redes Fortes A Camada Camada Redes Fortes (FC) toma a saída flattened de Pooling como entrada e realiza uma transformação linear utilizando multiplicação de matrizes. ```python def full_connected(x, W, b): # Multiplicação de matrizes usando tf. matmul return tf. matmul(x, W) + b ``` ## Arquitetura do Modelo A Arquitetura do Modelo consiste em duas camadas de Convolução, camadas de Pooling Max, e um camada Camada Redes Fortes para o conjunto de dados MNIST com 10 classes. ```python def create_layers(): # Layer 1 W_conv1 = init_weights([5, 5, 3, 32]) b_conv1 = init_bias([32]) conv1 = conv2d(images, W_conv1, b_conv1) pool1 = max_pool_2x2(conv1) # Layer 2 W_conv2 = init_weights([5, 5, 32, 64]) b_conv2 = init_bias([64]) conv2 = conv2d(pool1, W_conv2, b_conv2) pool2 = max_pool_2x2(conv2) # Layer Flattened pool2_flat = tf. reshape(pool2, shape=[-1, 7 * 7 * 64]) # Camada Camada Redes Fortes W_fc = init_weights([7 * 7 * 64, 1024]) b_fc = init_bias([1024]) fc = full_connected(pool2_flat, W_fc, b_fc) return fc ``` ## Treinamento da Rede [. . . ] # Rede Neural de Computação para Reconhecimento de Imagem Usando Camadas Convolucionais Este documento explica o processo de construção de um modelo de rede neural para reconhecimento de imagem usando redes neurais convolucionais (CNN). ## Sobrepassamento e Taxa de Aprendizado Ao construir um modelo de rede neural, é importante escolher uma taxa de aprendizado apropriada para evitar sobrerapazamento. Uma taxa de aprendizado baixa utilizará menos recursos e geralmente se usa em crescimento exponencial com valores como 2, 4, 8, 16, e o próximo seria 5, 12. Você pode usar qualquer número por lá, mas estes seriam os números ideais. ## Função de Perda Para medir a qualidade de nosso modelo, precisamos introduzir uma função de perda, que chamaremos de função de perda de entropia cruzada. Primeiro, vamos olhar para oque estamos alimentando. Alimentaremos o nosso ponto de desempenho com labels, e teremos as nossas labels verdadeiras e as nossas previsões. Esta função mede a média número de bits necessários para identificar um evento extraído do conjunto, que é basicamente a quantidade de erro nos dados. Vamos olhar ao erro médio, conhecido como a média. Portanto, estamos olhando para o erro médio nestes dados. ## Treinamento do Modelo Tomaremos o erro e sabermos a nossa função de perda ou função de desvio, que fará parte do treinamento do modelo. O Nos alimentaremos com volta em volta do setup de compartilhamento de código e otimizaremos com um otimizador de Adam, o que é o mais popular usado. Durante o treinamento, não modificaremos as taxes completamente; em vez disso, multiplicaremos o valor de troca por 0, 001 para fazer um pequeno ajuste nestas taxes. Antes de treinar o nosso modelo, precisamos inicializar todas as variáveis globais TensorFlow com a função `tf. global_variables_initializer()`. Isto é essencial para inicializar nossas variáveis antes do treinamento. Depois de inicializar as variáveis, criaremos uma `graph_session` para executar nossa treino. Pediremos dados em lote de 500 pontos cada. Vamos adiante e treinaremos os dados para 500 iterações ou passos usando um laço. ## Cálculo da Precisão A cada 100 passos, vamos imprimir uma declaração de impressão para manter rastreamento do desempenho do modelo. Calcular a precisão comparando as previsões e labels verdadeiras. ```python precisão = tf. reduce_mean(tf. cast(tf. equal(y_previsão, y_verdadeiro), tf. float32)) ``` ## Treinamento do Modelo Finalmente, vamos treinar o modelo com o seguinte código: ```python with sess. as_default(): sess. run(tf. global_variables_initializer()) para i em range(500): _, taxa_de_aprendizado, perdas, precisão = sess. run([op_de_treino, taxa_de_aprendizado, perda, precisão], feed_dict={X: X_treino, Y: Y_verdadeiro}) se (i + 1) % 100 == 0: print('Passo %d: Perdas = %f, Precisão = %f' % (i + 1, taxa_de_aprendizado, precisão)) ``` Isto vai executar o modelo, inicializar nossas variáveis, treinar os dados, e calcular a precisão a cada 100 passos. Depois de treino, teremos um modelo sólido que pode reconhecer imagens com redes neurais convolucionais. # Tutorial sobre Rede Neural Recurrente (RNN) Vamos começar nossa aula sobre Redes Neurais Recurrentes (RNNs). Meu nome é Richard Kirschner e faço parte do time de [Simplilearn](www. simplylearn. com). Este tutorial está destinado a você, seja iniciante ou experiente. Neste tutorial, abordaremos os fundamentos da rede neural recursiva, examinaremos uma aplicação prática, e analisaremos um caso de estudo que vai nos ensinar a usar a LSTM (Long Short Term Memory) em Keras, um módulo do TensorFlow que permite treinar redes neurais de profundidade. ## Pré-requisitos - Baixe e instale [Anaconda](https://www.anaconda.com/download/) - Crie um ambiente virtual do TensorFlow, com a seguinte versão: `pip install tensorflow==2. 5. 0` - Instale o [Keras](https://keras.io/): `pip install keras` ## Agenda 1. Fundamentos do RNN 2. Análise da aplicação 3. Case study ## Parte 1 - Fundamentos do RNN Como seu nome sugere, a RNN é um tipo de rede neuronal recursiva, capaz de capturar as características do passado durante o treinamento e gerar resultados mais precisos, particularmente quando o tamanho dos dados de entrada é longo ou o desafio a ser resolvido possui sequências complexas. Algumas aplicações de RNNs: - Análise de série temporal - Tradução de textos - Classificação automática de sentimento ### Recapitulando Vamos fazer uma pequena revirada das teorias abordadas na seção sobre fundamento da RNN. **Gradiente Vânzante e Explosivo**: RNNs tem a propriedade de treinar difícil por conta da crescente inestabilidade degradiente causado por sua complexa topologia de laços, possibilitando o *blow up* do valor das funções objetivo, tornando assim difícil a aplicação deste tipo de modelo a mais complexos desafios de aprendizagem profunda. **RNNs Long Term Memory**: o LSTM (Long Short Term Memory) foi desenvolvido com a finalidade de melhorar a RNNs na manipulação de informações de longa duração. Alterações adicionais em seus neurônios esconde-e-forget auxiliam nisso. ### Case study: Auto Complete em Google O AutoComplete de Google, uma funcionalidade marcante no site, usa uma rede neuronal recursiva para analisar o que o usuário escreve, capturar os padrões e completar as informações baseado em sequências similares, fazendo o resultado mais intuitivo. Nosso primeiro caso de estudo utilizaremos Keras, com TensorFlow no fundo, para analisar o conjunto de dados da BBC e gerar o AutoComplete para textos relacionados a assuntos atuais. --- Veja [esta aula de vídeo](https://www.youtube.com/watch?v=lWkFhVq9-nc) para aprender mais sobre Rede Neural Recurrente (RNNs) usando TensorFlow e Keras. # Redesses Neurais Recorrentes: Visão Geral e Desafios Redesses Neurais Recorrentes (RNNs) são um tipo de rede neuronal artificial comumente utilizada para reconhecer padrões em sequências de dados, como fala, escrita à mão ou texto. Este texto entrevista as basicas da RNN, apresenta diferentes tipos de RNN e discute os desafios que surgem durante sua treino. ## Redesses Neurais Simples (Vanilla) A variação mais comum de uma rede neuronal recorrente de um-para-um, com saída simples é conhecida como uma rede neuronal simples. Devido à sua simplicidade, é frequentemente usada para problemas de aprendizagem de máquina convencionais. A origem do termo "vanilla" vem da ideia de que ela é considerada como um sabor básico, mas sua simplicidade torna-a facilmente compreensível para iniciantes. Uma rede neuronal simples recorrente processa apenas um input e pode fornecer vários valores de saída de acordo com o problema. Por exemplo, na captionação de imagens, temos um input de uma imagem e diversas possíveis saídas representando palavras ou frases que podem ser utilizadas para descrever a imagem. ### Redesses Longas e Redesses Sequência para Sequência As Redesses Longas e Redesses Sequência para Sequência são utilizadas para problemas que requerem o processamento de uma sequência de inputs e gerar uma sequência de saídas. Exemplos de tais problemas incluem a tradução automática, onde uma frase extensa em inglês é traduzida em várias frases em diferentes idiomas, análise de sentimento de sentença, onde uma sentença dada pode ser classificada de acordo com a expressão de sentimento positivo ou negativo e captionação de imagens. ### O Problema do Gradiente Desaparecendo e Explodindo Um dos grandes desafios ao trabalhar com Redesses Neurais Recorrentes é o problema do Gradiente Desaparecido. Este ocorre quando a inclinação envolvida no cálculo dos gradientes é demasiado pequena ou demasiado grande, o que dificulta a treino. - Quando a inclinação é demasiado pequena, o problema é conhecido como o Gradiente Desaparecido, e a treino torna-se lenta e até para detê-la. Isto ocorre devido a perda de informação ao longo do tempo, resultando na perda de informação antes mesmo da terceira palavra de uma frase ou falha na sequência completa da lógica. - O problema do Gradiente Explodindo, por outro lado, ocorre quando a inclinação cresce exponencialmente, resultando em horas de treino longas, precisão ruim e até bloqueio do computador e erro de memória. ### Soluções para Problemas de Gradiente Various soluções têm sido propostas para abordar os problemas de gradiente em Redesses Neurais Recorrentes. Alguns dos soluções mais populares incluem: 1. **Inicialização de Identidade**: Minimizando as identidades que entram e a apenas passando informações relevantes para que a rede possa identificar patters mais eficientemente. 2. **Propagação Truncada**: Restringindo a informação enviada para as camadas seguintes e diminiuindo seu tamanho, assim apostando no reduzir a capacidade de aprendizagem e abordando o problema do Gradiente Explodindo. 3. **Talhagem de Gradientes**: Restringindo o tamanho dos gradientes durante a treino para ajudar a diminuir o modelo de treino e ajudar com o Gradiente Desaparecido. ### Redesses de Memória de Curtos Para Longo termo (LSTMs) Para superar as limitações de Redesses Neurais Recorrentes convencionais, as Redesses de Memória de Curtos Para Longo termo (LSTMs) foram desenvolvidas. As LSTMs são uma variação especial de Redes Neurais Recorrentes que são capazes de aprender dependências de longo prazo e lembrar informações por longos períodos de tempo. As LSTMs consistem de quatro camadas interagindo especificamente para garantir que a rede processe dados sequenciais com dependências de longo prazo de forma eficaz. As LSTMs utilizam a porta recém coletada, porta de entrada, porta de saída e estado da célula para aprender, atualizar e lembrar informações selectivamente. Abaixo está um exemplo para ilustrar a funcionamento de LSTMs: Consideremos a seguinte sequência de entradas: ``` O pessoa que levei o meu bicicleta e (vazio) um ladrão Os estudantes que ingressaram em engenharia com (vazio) de asia O pessoa que leveu o bicicleta para (vazio) um ladrão ``` Para identificar as palavras em branco em cada sequência, as LSTMs deveriam se lembrar do contexto no início da sequência. Utilizando as LSTMs e propagação, a rede pode aprender a reconhecer padrões e prever as palavras que estão faltando com base nas sequências fornecidas. # Mecanismos de Porta de Entrada em LSTM e Previsão de Preços de Acessos usando Rede de RNA LSTM ## Mecanismos de Porta de Entrada em LSTM Esta seção explica o papel das três portas principais de uma célula de LSTM: a porta de entrada, a porta de saída e a porta de esquecimento. ### Porta de Entrada A porta de entrada determina qual informação deve ser permitida através de sua importância no passo atual do tempo. Se este parecer um pouco complexo, não se preocupe porque a maior parte do trabalho de programação será feito quando chegamos ao caso de estudo. No entanto, compreender que este é parte do programa é importante quando você tenta definir as configurações. Nota que ao olhar para isso, deve ter algumas semelhanças com uma rede neuronal de propagação para frente, na qual temos um valor associado a um peso mais um offset. As etapas importantes envolvem qualquer uma das camadas de rede neuronal, independentemente de estar propagando informação de um para o próximo ou simplesmente fazendo uma propagação simples da rede neuronal. Do ponto de vista humano, ao sair de meu traje, considere a informação atual em `x_t`. John é um ânime no futebol. Ele me disse ontem por telefone que serviu como capitão de sua equipe de futebol da faculdade. Isso é nossa entrada. Análise da Porta de Entrada: * A informação "John é um ânime no futebol" e "ele serviu como capitão da equipe de futebol da faculdade" é importante. * "Ele me disse ontem por telefone" é menos importante e portanto é esquecido. Este processo de adição de alguma informação nova pode ser feito pela porta de entrada. Agora, este exemplo é em forma humana, e vamos treiná-lo em apenas um minuto. Mas como seres humanos, se eu quisesse obter esta informação de uma conversa, talvez seja o Google Voice escutando em nós, ou algo similar, como como podemos separar a informação? Eu não quero lembrar que ele falou comigo ontem pelos telefones, ou talvez esse seja importante, mas neste caso não é. Eu quero saber que ele era o capitão da equipe de futebol, eu quero saber que ele serviu, eu quero saber que John é um ânime no futebol e que ele era o capitão da equipe de futebol da faculdade. Aqueles são as duas coisas que quero lembrar como um ser humano. Novamente, medimos a grande maioria deste pelo ponto de vista humano, e isso é como tentamos treinar delas, para que possamos entender estas redes neuronais. ### Mecanismo de Esquecimento A Porta de Esquecimento determina qual parte do estado da célula passado deve ser esquecida, esquecendo informações irrelevantes e mantendo informações importantes. ### Mecanismo de Saída O Mecanismo de Saída decide qual parte do estado atual da célula fará parte da saída, com base no estado atual e estado oculto. ## Previsão de Preços de Acessos usando Rede de RNA LSTM Finalmente, vamos ao caso de estudo: implantação do LSTM. Vamos prever os preços de ações usando a rede LSTM baseada nos dados de preços de ações entre 2012 e 2016. Vamos tentar prever os preços de 2017, e isso será um conjunto de dados bem limitado. Não iremos fazer a totalidade do mercado de valores movimentados; essa saída no mercado de valores de Nova York gera aproximadamente três terrabytes de dados por dia, isso abrange todas as transações subindo e caindo de todas as ações em jogo, e cada uma segundo a segundo ou nanosegundo a nanosegundo, mas vamos limitar isso apenas a algumas informações básicas. Portanto, não vá pensando que você vai se tornar rico hoje, mas no mínimo pode dar uma olhadela, pode dar um passo adiante em como começar a processar informações como preços de ações. Uma aplicação válida para aprendizado de máquina nos mercados atuais. ### Implementação do caso de estudo de LSTM Agora, vamos mergulhar. Vamos importar nossas bibliotecas, importar o conjunto de treino, fazer a escala funcionar e continuar com a implementação. *Obs: Esta implementação é feita usando Jupyter Notebook (Anaconda) para Python 3. 6. * *Obs: Esta implementação é para fins ilustrativos apenas e não é intencionado para fornecer conselhos financeiros ou ser utilizado para realizar (! ) transações. * # Ajuste de Dados para Previsão de Série Temporal com Ajuste de Feature no Python ## Introdução Neste tutorial, vamos aprender a ajustar dados para previsão de série temporal usando **Ajuste de Feature** com Python. vamos utilizar a biblioteca **sklearn** para nossa prestação e o `MinMaxScaler` para a escala das nossas características. ## Entendendo Bias e Escalamento Antes de começar a escalar, é fundamental remover os burstos presentes nos dados que podem surgir de diferentes ações que possuem valores extendidos de forma significativa. Isso pode ser ilustrado através de um gráfico: [Ilustração de Gráfico] Neste exemplo, uma ação possui um valor de 100, enquanto outra possui um valor de 5. Isso pode provocar um bias entre diferentes ações, como se vê no gráfico. Para superar isso, vamos padronizar nosso dados, dizendo que 100 será o máximo (1) e 5 será o mínimo (0), e tudo o resto será escalonado de forma a "comprimir" os dados entre 1 e 0. ## Étapas de Escalamento 1. Carregar os dados 2. Criar um objeto `MinMaxScaler` 3. Ajustar o escalador ao conjunto de treinamento 4. Escalonar o conjunto de treinamento 5. Usar o escalador aprendido para o conjunto de teste (opcional) ### Carregando Dados ```python import pandas as pd # Carregar os dados data = pd. read_csv("yourdata. csv") ``` ### Criando o objeto `MinMaxScaler` ```python from sklearn. preprocessing import MinMaxScaler # Criar um objeto escalador scaler = MinMaxScaler() ``` ### Ajustar o Escalador ao Conjunto de Treinamento ```python # Ajustar o escalador ao conjunto de treinamento scaler. fit(X_treino) ``` ### Escalonando o Conjunto de Treinamento ```python # Escalonar o conjunto de treinamento X_treino_escalonado = scaler. transform(X_treino) ``` ### Escalonando o Conjunto de Teste (Opcional) ```python # Transformar o conjunto de teste usando o escalador aprendido X_teste_escalonado = scaler. transform(X_teste) ``` ## Colocando tudo em prática Com os conjuntos de treinamento e de teste escalonados, podemos agora prosseguir com nossa análise e previsão. Use os conjuntos escalonados como entrada para o algoritmo de aprendizado como necessário. # Construção e Treinamento de Modelos com Cross (Redes Neurais) ## Introdução Neste tutorial, vamos construir e treinar um modelo regressor usando Cross, uma biblioteca de aprendizado profundo. Encontramos um modelo pré-construído e iremos agora compilá-lo e ajustar os dados. ## Compilando e Ajustando o Modelo Primeiramente, precisaremos compilar nossa modelo. ```python model. compile(optimizer='adam', loss='mean_squared_error') ``` Em seguida, iremos ajustar os dados ao nosso modelo. ```python model. fit(x_treinamento, y_treinamento, epochs=100, batch_size=32) ``` ### Gestão de Dados de Grande Escala Uma das forças de Cross é a sua capacidade de lidar com grandes ficheiros armazenando batchs menores em vez de carregar todo o ficheiro na memória RAM. ## Execução do Modelo Agora, vamos executar nosso modelo compilado. ```python model. run(x_treinamento, y_treinamento) ``` Isto poderá demorar um pouco em meu computador (um laptop antigo), portanto, aguarde pacientemente. ## Avaliação do Modelo Após a execução do modelo, podemos avaliar o desempenho verificando a perda. ```python print(model. evaluate(x_teste, y_teste)) ``` ## Preditores e Visualização dos Resultados Por fim, iremos fazer previsões usando o nosso modelo treinado e visualizar os resultados. ```python previsões_preços = model. predict(x_teste) preços_reais = y_teste plt. scatter(previsões_preços, preços_reais) plt. xlabel('Previsões de Preços') plt. ylabel('Preços Reais') _ = plt. title('Previsões vs Preços Reais') ``` Isto nos dará uma gráfica de dispersão dos preços previstos contra os preços reais para os dados de teste. O objetivo é minimizar a diferença entre os preços previstos e reais. # Tutorial sobre Redes Neurais | Tutorial de Redes Neurais Artificiais | Tutorial sobre Aprendizagem Profunda | Simplilearn [URL: https://www.youtube.com/watch?v=ysVOhBGykxs] Idioma: en ## Boas-vindas ao Tutorial de Redes Neurais Eu sou Richard Kirschner e pelo menos estou parte do time de Simplilearn! O que podemos fazer para você hoje? Sim, hoje, iremos abordar o que é uma rede neural? O que redem neurais podem fazer? Como funciona uma rede neural? Tipos de redes neurais e, então, vamos nos aprofundar no uso de uma rede neural. Utilizaremos uma rede neural recurrente (RNN) do TensorFlow com Python para identificar os rostos de cães e gatos. Pense nisso: *Rede neural de classificação de animais de estimação pura! * Agora, em primeiro lugar, vamos nos aprofundar e aprender quais são redes neurais e por que elas podem ser utilizadas. ## A Rede Neural: Por que são relevantes A praticidade é que você já pode ter usado rede neural em todos os seus dias. Mesmo que vary possa não conseguir te lembrar, rede neural está de moda agora. Imagine quando você pede por algo em uma busca como Google ou Siri. Qualquer assistente digital que use o Siri ou você possui. Neste mundo moderno, redes neurais não apenas são essenciais quanto estão ajudando a nos guiar e aumentar a conforto nas nossas vidas! Como você já sabe, uma rede neural é baseada em ideias da funcionalidade das células humanas. De uma maneira simples, redes neurais foram criadas com a intenção de pensar como seres humanos e resolver problemas utilizando a nossa própria inteligência. Hoje, porém, o nosso lembrete-tudo estou me preocupado que possamos ficar debaixo de nosso pescoço. Estas são várias coisas que redes neurais podem fazer hoje: 1. Tradução de texto: já foi usado nos sites de internet, como [Google Tradutor](https://translate.google.com/) 2. Reconhecimento de voz: Você poderá encontrá-lo em alguns telefones inteligentes. Por exemplo, o iPhone 5 utiliza uma rede neural para reconhecimento de comando. Também se pode aplicar para diferentes idiomas, e, em caso de comunicação deficiência, até pode se substituir pelos sinais de mão! ``` **Siga esta série com novos videos, dê o seu "Like", subscreva-me, comente e cadastre-se em nossos cursos simples e agradáveis. ** # Redes Neurais Artificiais: Entendendo Funções de Ativação e Tipos Esta guia fornece uma visão geral sobre redes neurais artificiais, com ênfase nos aplicativos de função de ativação e sobre suas influências no desempenho da rede. ## Introdução Nesta guia, exploredos funcionamentos de redes neurais artificiais, principalmente da importância das funções de ativação e de sua influência no desempenho da rede. ### Camadas Ocultas Aqui, vemos a camada de entrada (`x1`) entrando, e ela, de fato, vai para todos os diferentes nós das camadas ocultas, ou, no caso, vamos chamá-los de "configuração da rede" nós. Os pontos amarelos representam os valores de `x1`, e tomamos o valor de `x1`, multiplícado pelo peso para a próxima camada oculta. Assim, `x1` aciona a camada oculta um, `x1` aciona a camada oculta dois, etc. A biaise é frequentemente representado como outro ponto verde ou amarelo e é dado um valor de um. Todos os pesos então vão do biaise para o próximo nó. A biaise pode ser alterado, e é importante lembrar que, às vezes, é necessário para garantir que a resposta correta é obtida. Há coisas que podem ser feitas com ele, mas a maioria dos pacotes o lidam por si próprio. No entanto, se você se afunda profundamente em redes neurais, você precisará entender o papel da biaise. ### Soma Ponderada e Ativação A soma ponderada da entrada serve como entrada para a função de ativação para decidir quais nós ativar e para extrair recursos. Enquanto a sinalização fluem nas camadas ocultas, a soma ponderada dos inputs é calculada e é enchida para a função de ativação na camada, para decidir quais nós ativar. ### Extração de Recursos Isso é nossa extração de recursos do número de placas, e você pode ver que esses ainda são nós ocultos no meio, o que se torna importante. ### Desvios por meio da função de Ativação Agora, comemoraremos um pequeno desvio e olharemos para a função de ativação, para que possamos começar a entender onde algumas das jogatins vão quando você está brincando com redes neurais em seu ambiente de programação. Vamos olhar para as diferentes funções de ativação: 1. **Função de Símbolo**: Esta função, 1 sobre 1 mais e elevado ao poder de `x`, apresenta o valor de `x` e gera casalmente um 0 e um 1 com uma pequena área no meio onde ela crossing sobre. Podemos utilizar esse valor para introduzir para outra função. 2. **Função de limiar**: Se você não se preocupar com a incerteza no meio, poderá simplesmente dizer, "se `x` é maior ou igual a zero, então `x` é um; se não, então `x` é zero. " É um 0 ou 1, com nenhum meio intermedio. 3. **Função ReLU**: Esta função apresenta o valor, mas se estiver acima de um, ele vai ser 1, e se estiver abaixo de zero, ele vai ser zero. Ele vai travar-lo no fim desses dois extremos, mas permitirá todos os valores no meio. 4. **Função hiperbólica (tanh)**: Esta função, 1 menos e elevado ao poder de -2x sobre 1 mais e elevado ao poder de -2x, se move entre -1 e 1. Ele está bastante ao mesmo tempo, um tanto diferente em que ele se move de -1 a 1, então você verá alguns desses ir para zero a 1, mas esta uma se move de -1 a 1. Estas funções de ativação são essenciais para que a informação seja passada de uma camada para a próximo, auxiliando a rede a entender a entrada e seu nível de incerteza. A escolha da função de ativação pode ter um impacto significativo no desempenho da rede. ### Modelo de Rede Neural Por fim, o modelo produz o resultado da aplicação de uma função de ativação adequada à camada de saída. Vamos entrar, visualizar isto e a análise ótica do caractere (OCR) por meio dos sistemas utilizados nas imagens para converter em texto para identificar o que está escrito na placa. A saída é então recuada e ajustada para minimizar a taxa de erro. ### Tipos de redes neurais artificiais - **Rede Neural de Propagação Diretiva**: É a forma mais simples de uma rede neural, com os dados viajando somente em uma direção (entrada à saída). Os dados são adicionados enquanto passam pelos pesos, passando da camada de entrada para a oculta e, em seguida, para a saída. A recuperação reversa nunca é usada salvo quando se está treinando a rede. - **Rede Neural de Base Radial**: Este modelo classifica os pontos de dados com base na sua distância a um ponto de centro. Ele pode ser usado quando você não tem o suficiente dados de treinamento e pode ajudar a encontrar conexões que você pode notar antes. - **Rede Neural de Organização auto-adjumtrativa**: Esta rede funciona com vetores em dimensões arbitrárias e cria um mapa composto de nós discretos. Ela descobre uma forma de separar os dados e conectar diferentes peças de dados juntas, tornando-o um ótimo para reconhecer padrões em dados, como no análise médica. - **Rede Neural Recorrente**: As camadas ocultas nas redes neurais recorrentes lembram seu saída da hora anterior e eles se tornam parte de seu novo entrada. Isso é útil na robótica, navegação de dronos e aplicações de text-to-speech, onde você quer saber o estado anterior e a taxa de variação para prever a próxima ação. - **Rede Neural Covolucional**: Em nosso mundo de identificação de imagens atuais, as redes neurais covolucionais (CNN) são usadas para separar imagens, como nos casos em que várias pessoas estão em uma foto e elas são capazes de identificar e reconhecer cada pessoa. - **Rede Neural Módular**: Esta rede tem uma coleção de diferentes redes neurais funcionando juntas para produzir a saída. É em rápido crescimento como área específica, particularmente em problemas complexos envolvendo várias redes neurais funcionando em conjunto para resolver um único problema. # Reconhecimento Facial: A Abordagem de Topo da Linha Nesta seção discutimos as aplicações de reconhecimento facial que estão ainda em processo de pesquisa. ## Pipline em Redes Neurais Artificiais O termo pipiline é frequentemente usado no código de Python e em várias configurações de redes neurais. Ele se refere ao processo de ligar várias redes neurais em sequência, onde os dados são passados de uma rede para a outra ou são alimentados na próxima rede. ``` Neste exemplo, tomamos os dados de uma rede neuronal e os alimentamos em outra, depois em uma terceira, e assim por diante. A maneira como ligamos as redes neurais é de topo de linha e experimental, pois cada domínio específico tem requisitos diferentes. ``` ### Redes Neurais Artificiais Disponemos de vários tipos de redes neurais artificiais: - Rede Neural de Entrada Frecamente Direta - Rode Basis Function Neural Network - Rode Neural de Organização Auto-Consiciosa de Cohenon - Rode Neural Recurrente - Rode Neural Convolucional - Rode Neural Módular Apesar das cores no cérebro não coincidirem com os cérebros humanos, estas redes foram desenvolvidas baseadas na nossa compreensão da maneira como os seres humanos aprendem. Como continuamos a entender os processos de aprendizado humano, podemos criar sistemas mais avançados na indústria informática para imitar estes processos. ## Caso de Uso: Classificação de Gatos vs Cachorros Nesta parte, usaremos o nosso sistema para classificar fotos de gatos e cachorros usando uma rede neuronal. ### Enunciado do Problema Nosso objetivo é classificar fotos de gatos e cachorros usando uma rede neuronal. Disponemos de uma variedade de fotos para ambos os gatos e cachorros, e o desafio é identificar corretamente qual é qual. Este caso de uso será implementado em Python 3. 6. ### Configuração do Ambiente Usaremos o Keras neste projeto. Para começar, precisamos importar os pacotes necessários: ```python from keras. models import Sequential from keras. layers import Conv2D, MaxPooling2D, Flatten, Dense ``` ### Visão Geral do Keras O Keras opera sobre o TensorFlow, CNTK ou Theano. O TensorFlow é um dos pacotes mais usados atualmente, mas se lembre de que a paisagem poderá mudar no futuro. ``` Para mais informações, visite o website oficial do Keras: https://keras.io ``` ### A Construção da rede neuronal Faremos agora a nossa rede neuronal e adicionaremos camadas: ```python # Inicialize a rede neuronal de classificação classificador = Sequential() # Adicionar a primeira camada de convolução classificador. add(Conv2D(32, (3, 3), input_shape=(64, 64, 3))) # Adicionar a função de ativação classificador. add(Ativation('relu')) # Adicionar mais camadas à medida que forem necessárias. . . ``` Lembre-se de definir o input shape para correspondê-lo aos dados que estás à utilizar. Se os dados não corresponderem ao input shape, encontrarás erros. Este é apenas um resumo do processo. Nos próximas seções, mergulharemos mais profundamente na arquitetura da rede neuronal, treino e avaliação. Acompanhe o progresso! 💪🏼📈🔥️ # Redutor Neural de Convolução (CNN) para Classificação de Imagens: Uma Introdução para Iniciantes ## Introdução Bem-vindo a esta introdução sobre a criação de um Redutor Neural de Convolução (CNN) para classificação de imagens usando Keras em Python. Neste tutorial, vamos abordar conceitos básicos e passos envolvidos na criação de um CNN desde o início. ## Camada ReLu e Conversão 2D ### Camada ReLu Como já foi mencionado anteriormente, a camada ReLu (Unidade Linear Retificada) é a função de ativação mais comummente utilizada em CNNs devido a sua velocidade e simplicidade. Ela não possui cálculos adicionais, apenas saída do valor que entra baseado nos pesos e do valor que entra. Se o resultado for maior que 1, é considerada boa; se for menor que 0, é considerada inativa. ### Conversão 2D A Conversão 2D é um passo crucial em nossa CNN pois converte os dados de imagem 3D (64 x 64 x 3 para fotos em cores) em um formato 2D, o que faz com que ele seja adequado para trabalhar com nossa CNN. O formato convertido é consciente da estrutura bidimensional da imagem, garantindo que diferentes peças estejam próximas umas das outras. No seguinte, desceremos para detalhes na arquitetura da CNN. ## Arquitetura da CNN Nossa CNN terá as seguintes camadas: 1. Camada de Entrada: Um tensão 3D única de forma (64, 64, 3) para uma imagem em cores. 2. Camada Convolucional 1: Camada convolucional com filtros 2D, camada de ativação ReLu, e um tamanho de pool de 2x2 para pooling max. 3. Camada Oculta 1: Uma camada densa que reduz os dados planos para 128 unidades (sinta-se livre para experimentar com diferentes números). 4. Camada Oculta 2: Outra camada densa para o processamento final e saída. ## Treinamento da CNN Para treinar a CNN, vamos utilizar o optimizador Adam, um dos optimizadores mais comumente utilizados para CNNs. O optimizador é responsável pelas ajustes nos pesos durante o processo de retropropagação. Alguns outros optimizadores podem ser necessários em determinadas situações, mas o Adam geralmente se comporta bem para ambos os conjuntos de dados pequenos e grandes. Durante o treinamento, vamos dividir nossos conjuntos de dados em um conjunto de treinamento e um conjunto de teste. O conjunto de treinamento é utilizado para aprender o modelo, enquanto o conjunto de teste é utilizado para avaliar o desempenho do mesmo. ## Conclusão Este tutorial apenas aborda uma visão geral de Redutores Neurais de Convolução para classificação de imagens. Aconselho que explore a documentação do Keras para obter mais informações sobre os vários parâmetros, perdas, e métricas disponíveis. Com uma grande quantidade de prática, você estará bem ao caminho para a criação e treinamento de CNNs poderosos para tarefas de classificação de imagens! ## Referências - [Documentação do Keras](https://keras.io/) - [Convolução](https://www.kaggle.com/mrd0x/what-matters-in-a-convolutional-neural-network-exploring-activation-functions) - [Optimizador Adam](https://keras.io/optimizers/adam/) - [Cross-Entropia Binária](https://keras.io/layers/losses/#binary-crossentropy) # Projeto de Aprendizado de Máquina: Classificação de Imagem ## Visão geral Neste projeto, construiremos uma rede neural para classificar imagens como 'gato' ou 'cão'. Usaremos um conjunto de dados de 8, 000 imagens (2, 000 para teste e 6, 000 para treino). A rede neural passará por 10 épocas, processando cada imagem 4, 000 vezes por época. Isso ajudará a garantir que a rede neural esteja bem treinada. ## Preparação - Importe os pacotes necessários (por exemplo, NumPy, Pandas, Image) - Pre-processastes as imagens (redimensiona, converte para array, etc. ) - Divida o conjunto de dados em conjuntos de treino e teste - Defina a arquitetura da rede neuronal e função de perda ## Treino 1. Inicialize a rede neuronal e o gerador de dados do treino 2. Ajuste os dados de treino na rede neuronal por 10 épocas (40, 000 passos no total) 3. Valide o modelo utilizando 10 imagens aleatórias do conjunto de teste após cada época ## Resultados - Exiba os valores de acurácia e perda para cada época - Avalie o desempenho do modelo no conjunto de teste ## Alterações Feitas - Reduzimos o número de épocas e passos de validação para fins de demonstração - Diminuímos o número de imagens processadas por época para aceleração do processo de treino ### Observações Importantes - O número reduzido de épocas e passos de validação não fornecerá resultados precisos em um ambiente comercial - Quando utilizarmos este código para um lançamento comercial, garanta-se que o número de épocas e passos de validação seja aumentado para obter melhor acurácia - O número reduzido de passos de validação pode levar a resultados de validação inacurados, pois apenas uma pequena quantidade de imagens é utilizada para validação ## Parte 3: Fazer uma Previsão 1. Importe os pacotes necessários (por exemplo, NumPy, Image) 2. Pre-processastes a imagem de teste e converta-a para um array 3. Use a rede neuronal para fazer uma previsão sobre a imagem de teste 4. Imprima o resultado da previsão ## Uso de exemplo ```python # Carregue a imagem de teste image_teste = load_image('image_teste. jpg') # Pre-processaste a imagem de teste image_preprocessada_teste = preprocess_image(image_teste) # Faça uma previsão sobre a imagem de teste previsao = modelo. predict(image_preprocessada_teste) # Imprima o resultado da previsão print('Previsão: ', previsao. argmax()) ``` ### Observações importantes - Garanta que a rede neuronal esteja treinada antes de fazer previsões - O resultado da previsão será o índice da classe com a probabilidade prevista mais alta (por exemplo, 0 para 'gato', 1 para 'cão') # Tutorial de Redes Neurais Bem-vindo à aula de hoje! Nesta aula voumos discutir os fundamentos de uma rede neuronal e aprender sobre aprendizagem profunda. Vamos aprender o seguinte: - O que é aprendizagem profunda? - O que é uma rede neuronal artificial? - Como funciona uma rede neuronal? - Vantagens de uma rede neuronal - Aplicativos de uma rede neuronal - O futuro das redes neurais ## História Brevíssima da Inteligência Artificial *O cérebro humano* procura a iluminação e senta-se em meditação, tentando compreender a si mesmo. Como o órgão mais complexo do corpo humano, o cérebro ajudar-nos na pensamento, compreensão e tomada de decisões. O segredo por trás de seu poder encontra-se no neurônio, que discutiremos mais tarde. Desde os anos 50, cientistas têm tentado copiar a funcionamento de um neurônio e utilizar para construir robôs inteligentes. Após várias tentativas infructuosas, os seres humanos finalmente desenhou um computador que pode reconhecer a fala humana. Somente após o ano 2000 que os seres humanos conseguiram dar à luz à aprendizagem profunda, uma técnica que permite aos computadores aprender por exemplo, semelhante ao aprendizado humano. ## O que é a aprendizagem profunda? A aprendizagem profunda é uma técnica de aprendizagem de máquina que ensina a computadores aprenderem por exemplos. Em contraste com empregar uma programação fixa para reconhecer algo, a aprendizagem profunda realmente aprende. É nesta área que a aprendizagem profunda éferamente chamada de "caixa mágica" porque não se sabe realmente como ela aprende; controla-se apenas os aspectos que entram, e o computador retorna e diz "Eu tenho conhecimento". ## Redes neurais artificiais Vamos falar sobre as redes neurais artificiais. Para compreender como funciona uma neurônio artificiais, vamos começar falando sobre como funciona um neurônio real. Temos um input dendrite para o neurônio, que recebe informação de diferentes áreas. O processamento da informação acontece no corpo da célula, e a saída do neurônio é o axôn, que envia sinais para outros neurônios. Em uma rede neural artificiais, temos uma camada de entrada que representa o array de dados (por exemplo, píxels de uma imagem) e camadas escondidas, que são conectadas pelos pesos que somam todos os dados entrantes. A saída de cada camada escondida é enviada para a próxima, e finalmente, há uma camada de saída que fornece à rede a resposta dada para o dado entradas. ## Como funciona uma rede neuronal? Uma rede neuronal funciona processando um dado entrada através de várias camadas (camada de entrada, camadas escondidas, e camada de saída) para produzir uma saída. Em outras palavras, uma rede neuronal é um sistema de hardware e/ou software modelado sobre a operação de neurônios no cérebro humano. Este sistema aprende com os dados e adapta os seus pesos de acordo com as erros que ele faz em previsões. Por exemplo, vamos considerar uma rede neuronal simples treinada para reconhecer imagens de gatos e cães. A entrada para a rede será uma imagem de um gato ou um cão, e a saída será a correspondente etiqueta (gato ou cão). Durante o treinamento, a rede ajusta os seus pesos para minimizar o erro entre a saída prevista e a saída real (etiqueta). Depois de treinada, a rede pode usar-se para classificar imagens novas como um gato ou cão com base nos recursos que aprendeu durante o treinamento. ## Vantagens de uma rede neuronal - Sistemas não lineares: as redes neurais podem aprender de conjuntos de dados não lineares, o que faz com que sejam altamente versáteis para uma ampla gama de aplicações. - Aprendendo sozinho: após o treinamento, redes neurais podem aprender e generalizar de novos dados, o que faz com que sejam altamente escaláveis e adaptáveis a novas situações. - Danos resistentes: as redes neurais são resistentes a ruído no dados, o que os tornam úteis para aplicações onde o dados podem ser ruido ou incompletos. - Aprendentes adaptáveis: as redes neurais podem se adaptar à distribuição de dados alterada, o que as tornam úteis para aprendizado online e tomada de decisões em tempo real. ## Aplicações de uma rede neuronal - Reconhecimento de imagens e classificação - Reconhecimento de fala - Processamento de linguagem natural - Análise preditiva - Veículos autônomos - Diagnóstico e pronóstico médicos ## O futuro das redes neurais O futuro das redes neurais é excepcionalmente promissor, com desenvolvimentos promissores em áreas como aprendizado de reforço, redes neurais adversárias gerativas e transferência de aprendizado. Poucamos esperar uma adoção mais ampla de redes neurais nas várias indústrias, como financeira, médica e de transporte. Para mais informações, visite [www. simplylearn. com](http://www.simplylearn.com) para se certificar e ficar à frente. Se tiver alguma dúvida sobre o vídeo, sinta-se livre para perguntar ao nossa equipa de apoio. Você também pode descarregar os dados do vídeo contatando-nos ou postando suas dúvidas na seção de comentários do vídeo do YouTube. Obrigado por se juntar a nós hoje. Esperamos que tenha aprendido algo novo e emocionante! Fique à vanguarda para mais vídeos sobre redes neurais e outros tópicos de aprendizado de máquina. --- ID: ["#TutorialRedesNeurais", "O", "que", "é", "uma", "Rede", "Neuronal? ", "|", "Como", "Funciona", "as", "Redes", "Neurais", "Artificiais? ", "Tutorial", "Redes", "Neurais", "|", "Simplilearn"] TITULO: Tutorial de Redes Neurais: O que é uma rede neuronal? | Como funciona as redes neurais artificiais? URL: https://www.youtube.com/watch?v=VB1ZLvgHlYs IDIOMA: PT DESCRIÇÃO: Bem-vindo a esta aula onde discutiremos os fundamentos de uma rede neuronal e aprendizagem profunda. Voumos aprender o seguinte: O que é a aprendizagem profunda? O que é uma rede neuronal artificial? Como funciona uma rede neuronal? Vantagens de uma rede neuronal. Aplicações de uma rede neuronal. O futuro das redes neurais. Queira fazer uma breve viagem através da história da inteligência artificial e compreender como as redes neurais funcionam por trás das telas. # Tutorial de Aprendizado Profundo | Aprendizado Profundo com TensorFlow | Aprendizado Profundo usando Redes Neurais | Simplilearn Esse tutorial o levará por um caminho de introdução ao aprendizado profundo e mostrar-lhe como utilizar o TensorFlow para implementar conceitos de aprendizado profundo. Exploraremos as seguintes temáticas: - O que é aprendizado profundo? - Pré-requisitos para aprendizado profundo - Redes Neurais e Perceptrons - Tipos diferentes de redes neurais - Aplicações do aprendizado profundo - Treino de redes neurais - Código de demonstração usando TensorFlow e Python ## Aprendizado Profundo O aprendizado profundo é um subconjunto de inteligência artificial (IA), com foco nas redes neurais artificiais com muitas camadas. Em contraste com o aprendizado tradicional, a extração de características é feita automaticamente no aprendizado profundo, fazendo-o bem-sucedido para lidar com grandes, conjuntos não-estruturados e operações complexas. ## O que é uma Rede Neuronal? Uma rede neuronal é baseada em neurónios biológicos e é usada para simular a estrutura e a função do cérebro humano. Numa neurónio biológico, uma entrada é recebida através dos dendrites, processada no núcleo celular e uma saída é transmitida através de um sinapse. Em uma neurónio artificial, as entradas são processadas no equivalente do núcleo celular, e a saída é transmitida como saída. Múltiplas neurónios artificiais são interligadas da mesma maneira como neurónios biológicos. ## Aplicações do Aprendizado Profundo O aprendizado profundo tem muitas aplicações excitantes na vida real, incluindo: 1. Reconhecimento de Escrita à Mão - Uma rede neuronal é utilizada para converter caracteres escritos à mão em caracteres digitais que o sistema pode reconhecer. 2. Previsão de Bolsa de Valores - Uma rede neuronal pode examinar vários fatores e prever os preços diários da bolsa, ajudando os comissários de bolsa. 3. Problema do Vendendor Viagens (TSP) - Uma rede neuronal pode ser utilizada para resolver o TSP, fornecendo maior rendimento a um custo mínimo no setor de transportes. 4. Compressão de Imagem - Uma rede neuronal é utilizada para armazenar, criptografar e recriar imagens, otimizando a compressão e armazenamento de dados. 5. Aprendizado Profundo no Futuro - O futuro do aprendizado profundo é promissor, com opções mais personalizadas para os utilizadores e clientes, bem como o desenvolvimento de assistentes virtuais hiper-inteligentes. 6. Redes Neuronais na Medicina, Agricultura e Física - Redes neuronais já estão sendo utilizadas para ajudar em várias tarefas nesses e outros campos, incluindo entender células T e entender a análise estatística para curar doença e manter a saúde dos seres humanos. ## Conclusão Participemos por mais informações e publique seus questionamentos e comentários abaixo ou visite [www. simplilearn. com](http://www.simplilearn.com). Subscreva o canal de vídeos do Simplilearn e clique aqui para assistir a vídeos semelhantes. # Redes Neurálreichs e Perceptrons ## Introdução Uma rede neuronal é uma coleção de elementos computacionais interligados, ou neurônios, que trabalham juntos para processar informações. Um dos blocos básicos de redes neuronais é o perceptron, que pode consistir de no ménos um neurônio e pode executar determinadas funções, como classificação binária. ## O que é um Perceptron? O perceptron pode ser considerado como um dos blocos básicos de redes neuronais. Pode consistir de no ménos um neurônio e, em algumas ocasiões, mais, mas é possível criar um perceptron com apenas um neurônio. O perceptron básico recebe entradas (x1, x2, x3, . . . , xn), realiza uma função de soma, aplica uma função de ativação e produz um resultado binário (0 ou 1) com base no somatório pesado e a saída da função de ativação. ## O processo de treinamento de um Perceptron Durante o treinamento, os pesos e pesos bias são ajustados para minimizar o erro entre a saída do neurônio e a informação esperada ou marcada. O erro é feeding back e os pesos e bias são atualizados adequadamente para fornecer uma nova saída. Esse processo iterativo continua até que o erro seja reduzido ao mínimo. ## Aprendizado de um Perceptron Aprendizado de um perceptron é um processo de aprendizado básico usado para treinar perceptrons. Trabalha multiplicando cada entrada (x1, x2, x3, . . . , xn) por um peso, somando os produtos, adicionando um bias e passando o resultado por uma função de ativação. Os pesos, bias e valor de bias podem ser alterados durante o processo de treinamento, e assim que o treinamento for concluído, seus valores ficam fixos. ## Implementação de portas lógicas usando Perceptrons Warren McCulloch e Walter Pitts implementaram funções lógicas como AND, OR e NOR usando neurônios como uma escalada importante na década de 1940. Eles foram capazes de criar e implementar a maioria das portas lógicas comum usando um perceptron em camada única, exceto para XOR. A implementação de uma porta AND requer modificar os valores dos pesos de modo que a saída seja ativada apenas quando ambas as entradas são 1. Para uma porta OR, a saída dará 1 se qualquer uma das entradas for 1. Uma porta XOR, porém, requer uma rede neuronal em múltiplas camadas para sua implementação. ## Rede neuronal Uma rede neuronal é uma rede de neurônios interligados que pode resolver uma variedade de tarefas. Existem vários tipos de redes neuronais, como Redes Neuronais Artificiais, Redes Neuronais Convolucionais, Redes Neuronais Recursivas, Redes Neuronais Profundas e Redes de Crenças Profundas, cada uma com características e especializações únicas. ## Aplicações do Aprendizado Profundo O aprendizado profundo é amplamente utilizado em jogo (Alphago, veículos automáticos guiados e veículos autônomos), geração de música, imagem e texto (Redes Adversárias Gerativas), e diagnóstico médicos e saúde, onde pode melhorar o diagnóstico de doenças, como câncer e reduzir o trabalho de especialistas humanos. # Classificação de Imagens com Redes Neurais Este texto discute o processo de classificação de imagens usando redes neurais, com um foco em uma imagem específica de 784 pixels. O valor de cada pixel pode ser pensado como fornecendo informação sobre a imagem, e estes valores podem ser usados para treinar redes neurais para identificar as imagens. ## Valores de Pixel e Neurônios Cada neurônio na rede neuronal recebe entrada dos valores de pixel, e valor mais próximo de 1 sugerem que o neurônio representa branco, enquanto um valor próximo de 0 sugere preto. ! [Anaimação de Sal small](url_for_animation) Para treinar a rede neuronal, a imagem é planificada, e os 784 pixels inteiros são fornecidos como entrada. A rede neuronal poderá consistir em várias camadas, incluindo camadas ocultas e uma camada de entrada, uma camada de saída. Durante o processo de treinamento, a rede neuronal provavelmente errará inicialmente ao classificar a imagem, por exemplo, identificando uma circunferência como um quadrado ou um triângulo. O erro é então enviado de volta, e os pesos e escalas de neurônios são ajustados até que a rede identifique corretamente a imagem como um quadrado. ## Proceso de Treinamento Este processo é demonstrado para uma circunferência também. O neurônio recebe os 784 valores de pixel e é treinado para identificar um padrão para corretamente classificar a imagem. Como antes, a rede pode errar inicialmente na identificação da imagem e o erro é enviado de volta e os pesos e escalas são ajustados até que a rede identifique corretamente a imagem como uma circunferência. Logo, processa-se para um triângulo. ## Reconhecimento Independente do Posicionamento É importante fazer nota que a rede neuronal pode reconhecer imagens mesmo quando o objeto (neste caso o triângulo) não está no posicionamento exato. Por exemplo, se o triângulo estiver posicionado em uma esquina ou apenas no lado, a rede ainda reconhecerá-o como triângulo, demonstrando a ideia por trás do reconhecimento de padrões. ## Redes Neurais de Múltiplas Camadas O processo de treinamento pode envolver redes neurais de múltiplas camadas. Neste exemplo, há dois níveis escondidos entre a camada de entrada e saída. Cada camada apresenta pesos e escalas que são ajustados durante o processo de treinamento. ## Funções de Ativação Uma rede neuronal possui uma função de ativação para cada neurônio. Diferentes tipos de funções de ativação podem ser usadas, e a função de ativação determina se o neurônio será acionado ou não. O resultado da rede é comparado com o resultado real, e o erro é calculado usando uma função de custo. Este erro é então enviado de volta durante o processo de propagação de volta, que ajuda no ajustamento dos pesos e escalas e na redução do erro. ## Técnica de Otimização - Descida de Gradiente A técnica de otimização utilizada aqui é a Descida de Gradiente, que funciona diminuindo o erro. O taxa de aprendizagem tem um papel crucial neste contexto, e valor óptimo deve ser encontrado para evitar problemas com convergência e tempo de awaita. O processo de treinamento continuará até que o erro seja minimizado. ## Implementação do Aprendizado Profundo com TensorFlow O TensorFlow é uma plataforma popular para o implementação de aprendizado profundo, especialmente para redes neuronais. Nesse tutorial, orientaremos você pela meia passe pelas bases da implementação do aprendizado profundo com TensorFlow usando Python. O TensorFlow é uma plataforma de código aberto da Google. O TensorFlow trabalha com matrizes multidimensionais, conhecidas como tensores, que são fundamentais para modelos de aprendizado profundo. Elas consistem primariamente de dois componentes—tensores e gráficos (ou fluxo). # Aprendizado Profundo com TensorFlow: Entendendo e Implementando com o Banco de Dados MNIST ## Visão Geral do TensorFlow e Arrays Multidimensionais O TensorFlow é uma plataforma de aprendizado profundo popular e de código aberto desenvolvida e mantida pela Google. Um de seus pontos fortes é a sua capacidade de gerenciar arrays multidimensionais, o que acelera significantemente as computações em aprendizado profundo. É por isso que o TensorFlow é amplamente utilizado para o desenvolvimento de aplicações de aprendizado profundo. Notavelmente, o TensorFlow é uma ferramenta de aprendizado profundo, e os dados fluem por ele na forma de tensores. A parte de programação é única, pois primeiro é criado um gráfico para o fluxo de execução e depois é executado este gráfico numa sessão, que é conhecido como uma sessão no código do TensorFlow. Todos os dados estão manageados ou manipulados dentro dos tensores, e a processação acontece através de estes gráficos. ### A Rangem de um Tensor O rangem de um tensor indica a sua dimensão de uma forma. Por exemplo: - Rangem 0: escalar (apenas um número) - Rangem 1: vetor umidimensional (vetores umídiemensionais, como vetores de números unidimensionais) - Rangem 2: vetor bidimensional (gerealmente uma matriz) - Rangem 3: array tridimensional (arrays tridimensionais) . . . E assim por diante, é possível armazenar arrays multidimensionais como tensores. ### Propriedades de TensorFlow Hoje, o TensorFlow é um dos plataformas mais populares para aprendizado profundo, conhecido por suas: - Natureza aberta - Capacidade de se executar em CPUs assim como em GPUs (Unidades de Processamento Gráfico) O GPU é uma extensão de alta performance de um CPU que pode realizar operações iterativas ou computações extremamente rápidas, tornando-o adequado para computações em aprendizado profundo onde há muita computação iterativa, como a multiplicação de matrizes e mais. O TensorFlow suporta tanto o CPU quanto o GPU e oferece uma maneira única de escrever código para o mesmo. ## Reconhecimento de Dígitos à Mão: Um Exemplo do Banco de Dados MNIST Neste tutorial, vamos tomar o caso do reconhecimento de dígitos à mão, frequentemente referido como o "Olá Mundo" do aprendizado profundo. O Banco de Dados MNIST oferece uma coleção de 70. 000 dígitos à mão, com uma grande parte deles para treino, um conjunto teste e um conjunto de validação—todos rotulados. Estas imagens são escritas à mão e parecem assim: ! [Amostras de Dígitos à Mão](https://upload.wikimedia.org/wikipedia/commons/0/07/Mnist_examples.png) Vamos alimentar estes dados, junto com a informação de label, à nossa rede neural. Como as imagens são na forma de informação de pixel, vamos escalar seus dados para que possam ser alimentados em uma única linha em nosso aprendizado profundo. A rede neural será treinada usando uma configuração mais simples chamada de softmax, e um dos neurónios na camada de saída vai ativar-se para um dado entrada. Veja um exemplo: <br> ```markdown Entrada: [0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] Saída: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0. 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] ``` No exemplo acima, o neurónio nono na camada de saída ativa com um valor de 0. 9, indicando que o input é um número nove. Ao pessoal aparecem ativações semelhantes para diferentes dígitos. ## Setup e Código Vamos trabalhar num ambiente do Jupyter Notebook na nuvem, onde o código será executado. Aqui está uma visão geral do código: 1. Importar a biblioteca do TensorFlow: `import tensorflow as tf` 2. Carregar o Banco de Dados MNIST: `mnist = tensorflow. keras. datasets. mnist` 3. Proteger o rótulos: ```markdown mnist_db = mnist. load_data() labels = mnist_db[1] (labels, ) = tf. keras. utils. to_categorical(labels) ``` 4. Verifique a informação carregada para ver seu formato. 5. Criar o gráfico para a execução das computações, usando o modelo softmax neste caso, e execute a sessão. Siga explorando o aprendizado profundo com o TensorFlow para descobrir mais aplicações e técnicas potentes! 😊 # Tutorial do TensorFlow: Multiplicação de Matrizes com TensorFlow ## Introdução Neste tutorial, usaremos o TensorFlow para executar a multiplicação de matrizes, uma operação básica na álgebra linear, com o objetivo de criar uma rede neural simples. Este tutorial assume que você tenha um entendimento básico do TensorFlow e da álgebra linear. ## Pré-requisitos 1. Família com o TensorFlow 2. Entendimento básico da álgebra linear e da multiplicação de matrizes ## Criando o Gráfico do TensorFlow Aqui, vamos criar um gráfico do TensorFlow para a operação de multiplicação de matrizes e definir os placeholders e variáveis necessários para entradas e pesos. ``` import tensorflow as tf # Placeholder para os valores de entrada (x) e etiquetas encodadas em uma forma de uma (y) x = tf. placeholder(tf. float32, forma=(None, 784)) y = tf. placeholder(tf. float32, forma=(None, 10)) # Variáveis para pesos (w) e resultados (b) w = tf. Variable(tf. zeros(forma=(784, 10))) b = tf. Variable(tf. zeros(forma=(10))) # Define o gráfico como a multiplicação de matrizes de x e w, junto com o termo de resultado y_pred = tf. matmul(x, w) + b ``` ## Definindo a Função de Perda e Otimizador Em seguida, vamos definir a função de perda (entropia cruzada com logarítmos) e o otimizador (descendimento de gradiente) para minimizar o erro. ``` # Função de Entropia Cruzada entropia_cruzada = tf. reduce_mean(tf. nn. softmax_cross_entropy_with_logits(etiquetas=y, logits=y_pred)) # Otimizador de Descendimento de Gradiente optimizar = tf. train. GradientDescentOptimizer(aprendizado_automático=0. 001). minimize(entropia_cruzada) ``` ## Treinamento do Modelo Em seguida, usaremos o otimizador definido para minimizar a entropia cruzada, o que eficientemente treina o nosso modelo. Note que inicializamos as variáveis antes de cada passo de treinamento. ``` # Inicialização das variáveis init = tf. global_variables_initializer() # Loop de Treinamento (agradecemos o [controversy000030](https://www.youtube.com/watch?v=PpQWHd-i0dE) pelo código de exemplo) para l in range(1000): # Recupere os dados batch_x, batch_y = . . . # Executar um passo de treinamento único com sessão() como sess: sess. run(init) _, perda = sess. run([optimizar, entropia_cruzada], feed_dict={x: batch_x, y: batch_y}) # Opicional: Gravar a perda para cada passo de treinamento se l % 100 == 0: print('Passo: {0: 04d}, Perda: {1: . 4f}'. format(l, perda)) ``` ## Conclusão Neste tutorial, criamos uma rede neural simples usando o TensorFlow para executar a multiplicação de matrizes, treinada em um conjunto de dados. O processo de criação de um programa do TensorFlow difere do padrão de programação civil e requer uma certa prática para se tornar confortável com o fluxo. Feliz aprendizado profundo! 🚀 🚀 🚀 ```markdown # Guia Compreensivo de Treinamento de Aprendizado Profundo: Um Guia Completo Este documento fornece uma guia completa sobre o treinamento de aprendizado profundo, com uma perspectiva específica no conjunto de dados MNIST. ## Treinamento de Aprendizado Profundo em Lotes O treinamento de aprendizado profundo é comumente feito em lotes. Por exemplo, você pode ter 50, 000 imagens, mas você processaria-as em lotes de 100 ou 500, dependendo do tamanho do seu sistema. Aqui, utilizaremos 100 imagens por vez. ### Dados de Treinamento e Dados de Teste Lembre-se de que utilizamos apenas o conjunto de dados de treinamento para o treinamento, e o conjunto de dados de teste para testar o modelo. Você deve estar familiarizado com este conceito em aprendizado de máquina, pois não é específico ao aprendizado profundo. Seu conjunto de dados disponível é geralmente dividido em duas partes: conjunto de dados de treinamento e conjunto de dados de teste. Neste caso, estamos utilizando a função `mnist`, especificamente `mnist. train. next_batch()`, que pega as imagens e seus rótulos em lotes. O vantagem do banco de dados MNIST é que oferece algumas funções de helper úteis, e podemos evitar escrever nossa própria código para pegar os dados em lotes, economizando tempo e esforço. ### Fase de Treinamento Ao falarmos em "pegar", ela pega as imagens no `x` e os rótulos no `y`. Em seguida, utilizando o lote de 100 imagens, executamos o treinamento dizendo `sess. run(train_step, feed_dict={x: x_batch, y_: y_batch})`. Isso executa o mecanismo de treinamento, que passa as imagens através da rede neural e atualiza os pesos e offsets com base no feedback, fazendo isso por 1000 iterações. Por fim, após 1000 iterações, o modelo deve lurar em reconhecer estas imagens escritas à mão, mas não será 100% preciso. Os critérios de saída podem ser definidos como acurácia ou um número de iterações. ### Fase de Teste Quando o treinamento for concluído, testamos a acurácia destes modelos usando o conjunto de dados de teste. Estamos tentando isso aqui. O código pode aparecer um pouco complexo para aqueles que estão vendo isso pela primeira vez devido aos vários métodos de TensorFlow. Aqui, comparamos a saída com o que está realmente lá e calculamos a acurácia. ### Resultados O código inteiro está em uma célula, portanto, precisamos executar tudo de uma vez. Após 1000 iterações, a saída mostra a acurácia do modelo, que é à volta de 91%. Isso é muito bom para um exercício tão curto dentro de um curto período de tempo, mas em realidade isso pode não ser suficiente. ### Melhorias Futuras Nos próximos tutoriais, exploraremos maneiras de aumentar a acurácia, como mudando os parâmetros-chave como o número de neurônios ou o número de camadas para melhorar a acurácia ultrapassando 90%. ### Despedida Esperamos que este guia tenha sido útil. Se você gostou deste vídeo diga-nos e não deixe de inscrever-se no canal YouTube Simply Learn e clique aqui neste link para assistir vídeos semelhantes para nerdar e se certificar. Clique aqui para melhorar sua compreensão deixando comentários ou perguntas. --- ```