Python para negociação algorítmica - página 22
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Visualização de dados com matplotlib em 1 hora
Visualização de dados com matplotlib em 1 hora
Neste vídeo, o instrutor apresenta a importância da visualização de dados no aprendizado de máquina e explica como ela pode ajudar a entender grandes quantidades de dados coletados. As duas principais bibliotecas Python para visualização de dados, Matplotlib e Seaborn, são abordadas no curso.
O instrutor afirma que o curso foi desenvolvido principalmente para engenheiros de aprendizado de máquina, engenheiros de dados e cientistas de dados que desejam aprender Python. Para ilustrar o uso do Matplotlib, é fornecido um exemplo simples de plotagem de uma curva. A filosofia do Matplotlib gira em torno de alavancar a linguagem existente, Python, que se tornou o padrão para construir modelos de aprendizado de máquina e manipular dados. Ao combinar o Matplotlib com outros pacotes Python, os usuários podem aproveitar os inúmeros pacotes disponíveis para várias tarefas.
O vídeo enfatiza a importância de usar o pacote NumPy junto com o Matplotlib para computação científica. Embora o Matplotlib possa funcionar sem o NumPy, a utilização do NumPy pode economizar significativamente tempo e esforço. O NumPy fornece um poderoso objeto de matriz multidimensional e funções para manipulá-lo. Um exemplo é demonstrado no vídeo, onde uma curva com 100 pontos é gerada usando NumPy para calcular as coordenadas x e y. Essa abordagem se mostra muito mais rápida do que executar a operação usando Python puro. Além disso, o vídeo aborda a plotagem de duas curvas no mesmo gráfico para comparação, plotagem de dados de um arquivo extraindo e organizando os dados usando o código Python e plotagem de pontos em vez de itens de maneira linear.
O tutorial se aprofunda na criação de diferentes tipos de gráficos de barras usando a biblioteca Matplotlib. A função dedicada para criar gráficos de barras, "bar", é introduzida, o que leva a coordenada x para cada barra e a altura de cada barra como parâmetros de entrada. Ao ajustar parâmetros opcionais, os usuários podem criar vários efeitos e até mesmo gerar barras horizontais usando a função "barh". O tutorial também aborda a plotagem de vários gráficos de barras no mesmo gráfico e a criação de barras empilhadas usando um parâmetro especial na função "barra". Além disso, o vídeo aborda brevemente a criação de gráficos de pizza usando a função "torta".
Várias funções usadas na visualização de dados com Matplotlib são explicadas no tutorial. A primeira função abordada são os histogramas, que são representações gráficas de distribuições de probabilidade. A função "hist" e seus parâmetros são discutidos, permitindo aos usuários plotar facilmente os dados como histogramas. A segunda função abordada são os gráficos de caixa, que facilitam a comparação de distribuições de valores. O vídeo explica os componentes de um box plot, incluindo quartis, mediana, média e quantidades estatísticas de um conjunto de dados, e demonstra como gerá-los usando a função "boxplot". Por fim, o tutorial abrange a alteração de plotagens usando cores e estilos diferentes, como a definição de cores usando trigêmeos, quadruplicados ou nomes de cores HTML, bem como a definição da cor de um gráfico de curva.
O vídeo continua explicando como adicionar cores a gráficos de dispersão, gráficos de barras e gráficos de pizza usando o parâmetro "cor". Este parâmetro permite que os usuários controlem cores de pontos individuais ou alterem a cor comum para todos os pontos. O vídeo também aborda a importação de bibliotecas como módulos, usando aliases para facilitar a codificação e esclarecendo a representação de variáveis. Ressalta-se que quase tudo no Matplotlib e Python envolve funções, como a função "pi" e a função "show".
Em seguida, o tutorial abrange esquemas de cores personalizados e padrões de linha ao criar plotagens de caixa, marcadores e formas de linha. Ele demonstra a criação de marcadores personalizados usando formas predefinidas e a definição de marcadores personalizados usando símbolos de texto matemático. Além disso, explica como alterar facilmente as configurações padrão do Matplotlib usando o objeto de configuração centralizado, permitindo que os usuários adaptem o estilo visual, como fundo preto e anotações brancas, a diferentes contextos de uso.
O apresentador explica como salvar um gráfico em um arquivo usando a função "savefig" no Matplotlib. Eles também cobrem a adição de anotações a um gráfico, incluindo um título, rótulos para os eixos x e y, uma caixa delimitada e setas. O vídeo demonstra o processo de adicionar essas anotações para melhorar a clareza visual e a compreensão do gráfico. Além disso, ele mostra como controlar manualmente o espaçamento dos ticks no Matplotlib para ajustes precisos. O vídeo destaca as várias funções disponíveis no Matplotlib para anotar gráficos e torná-los mais autoexplicativos para os leitores.
Seguindo em frente, o instrutor discute a visualização de dados com o Matplotlib e apresenta o Seaborn, uma interface de alto nível para o Matplotlib. O Seaborn fornece diferentes parâmetros e funcionalidades em comparação com o Matplotlib. O instrutor mostra como criar visualizações usando o conjunto de dados integrado e os mapas de cores da Seaborn. O vídeo termina apresentando exemplos de como criar um gráfico de fator e utilizar mapas de cores para plotar dados. Por meio desses exemplos, os visualizadores obtêm informações sobre o uso de diferentes funções e ferramentas no Matplotlib e Seaborn para aprimorar suas habilidades de visualização de dados.
O vídeo explica como dimensionar plotagens usando a função "set_context" da Seaborn. Esta função permite que os usuários controlem os elementos do gráfico, como tamanho, com base no contexto em que o gráfico será exibido. Em seguida, esclarece a distinção entre os dois tipos de funções de Seaborn: funções de nível de eixo e funções de nível de figura. As funções de nível de eixo operam no nível de eixo e retornam o objeto de eixos, enquanto as funções de nível de figura criam plotagens que incluem eixos organizados de maneira significativa. Por fim, o vídeo fornece orientação sobre como definir eixos para um gráfico de caixa usando o objeto de subtramas de eixo Matplotlib.
Este abrangente tutorial em vídeo abrange uma ampla gama de tópicos relacionados à visualização de dados com Matplotlib e Seaborn. Ele começa apresentando a importância da visualização de dados no aprendizado de máquina e o uso do Matplotlib como uma biblioteca poderosa. Ele demonstra como traçar curvas, criar gráficos de barras, gerar histogramas e gráficos de caixa e personalizar cores, marcadores e estilos de linha. O tutorial também aborda como salvar gráficos, adicionar anotações e manipular o espaçamento dos marcadores. Além disso, apresenta o Seaborn como uma ferramenta de visualização alternativa com seu próprio conjunto de recursos e funcionalidades. Seguindo este tutorial, os visualizadores podem aprimorar suas habilidades de visualização de dados e comunicar efetivamente suas descobertas usando essas poderosas bibliotecas Python.
Tutorial de Deep Learning com Python, TensorFlow e Keras
Tutorial de Deep Learning com Python, TensorFlow e Keras
Saudações a todos e bem-vindos a uma atualização altamente antecipada sobre aprendizado profundo e Python com TensorFlow, bem como a um novo tutorial do Chaos. Já se passaram mais de dois anos desde a última vez que cobri o aprendizado profundo básico em Python e, durante esse período, houve avanços significativos. Entrar no aprendizado profundo e trabalhar com modelos de aprendizado profundo tornou-se muito mais simples e acessível.
Se você estiver interessado em se aprofundar no código do TensorFlow de nível inferior e nos detalhes intrincados, ainda pode consultar o vídeo mais antigo. No entanto, se você deseja começar com aprendizado profundo, não precisa mais passar por isso porque agora temos APIs de alto nível fáceis de usar, como Chaos, que ficam no topo do TensorFlow. Essas APIs tornam o aprendizado profundo incrivelmente simples, permitindo que qualquer pessoa, mesmo sem conhecimento prévio de aprendizado profundo, acompanhe.
Neste tutorial, faremos uma rápida revisão das redes neurais. Para começar, vamos entender os principais componentes de uma rede neural. O objetivo principal de qualquer modelo de aprendizado de máquina, incluindo redes neurais, é mapear entradas para saídas. Por exemplo, dadas as entradas X1, X2 e X3, pretendemos determinar se a saída corresponde a um cachorro ou a um gato. Nesse caso, a camada de saída é composta por dois neurônios representando a possibilidade de ser um cachorro ou um gato.
Para conseguir esse mapeamento, podemos empregar uma única camada oculta, onde cada entrada, X1, X2 e X3, é conectada aos neurônios da camada oculta. Cada uma dessas conexões tem um peso exclusivo associado a ela. No entanto, se nos limitarmos a uma única camada oculta, as relações entre as entradas e as saídas seriam lineares. Para capturar relacionamentos não lineares, que são comuns em problemas complexos, precisamos de duas ou mais camadas ocultas. Uma rede neural com duas ou mais camadas ocultas costuma ser chamada de rede neural profunda.
Vamos adicionar outra camada oculta, conectando-a totalmente com a camada anterior. Cada conexão entre as camadas tem seu próprio peso exclusivo. Por fim, a saída é derivada da camada final, onde cada conexão com a camada de saída possui um peso único. Em um nível de neurônio individual, o neurônio recebe entradas, que podem ser os valores da camada de entrada (X1, X2, X3) ou entradas de outros neurônios. Essas entradas são somadas, considerando seus pesos associados. Adicionalmente, uma função de ativação é aplicada para simular o disparo ou não do neurônio. As funções de ativação comuns incluem a função degrau ou a função sigmóide, que retorna valores entre 0 e 1. Em nossa rede neural, a camada de saída utiliza uma função de ativação sigmóide, atribuindo probabilidades a cada classe (cachorro ou gato). A função Arg max é então usada para determinar a classe prevista com base na probabilidade mais alta.
Agora que temos uma compreensão básica das redes neurais, vamos construir uma usando o TensorFlow. Em primeiro lugar, certifique-se de ter o TensorFlow instalado executando o comando "pip install --upgrade tensorflow". Você pode importar o TensorFlow como "tf" e verificar a versão atual usando "tf.version". Para este tutorial, o Python 3.6 ou superior é recomendado, embora o TensorFlow seja compatível com o Python 3.7 e versões posteriores no futuro.
Em seguida, importaremos um conjunto de dados para trabalhar. Utilizaremos o conjunto de dados MNIST, que consiste em imagens 28x28 de dígitos manuscritos variando de 0 a 9. Essas imagens serão alimentadas na rede neural e a rede preverá o dígito correspondente. Dividiremos o conjunto de dados em variáveis de treinamento e teste: X_train, Y_train, X_test e Y_test.
Para garantir um melhor desempenho, vamos normalizar os dados. Os valores de pixel das imagens atualmente variam de 0 a 255, então vamos dimensioná-los entre 0 e 1 usando a função TF.keras.utils.normalize.
Para construir o modelo, usaremos a API Chaos de alto nível, que simplifica o processo de criação e treinamento de redes neurais no TensorFlow. Chaos fornece um modelo sequencial chamado Sequential que nos permite empilhar camadas uma após a outra.
Aqui está um exemplo de como você pode criar um modelo de rede neural usando Chaos:
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Flatten, Dense
# Create a sequential model
model = Sequential()
# Add a flatten layer to convert the input into a 1D array
model.add(Flatten(input_shape=(28, 28)))
# Add a dense layer with 128 neurons and ReLU activation
model.add(Dense(128, activation='relu'))
# Add another dense layer with 10 neurons for the output and softmax activation
model.add(Dense(10, activation='softmax'))
# Compile the model
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
No código acima, importamos os módulos necessários do TensorFlow e do Chaos. Criamos um modelo sequencial e adicionamos camadas a ele usando o método add. A primeira camada é uma camada Flatten que converte a entrada 2D (imagens 28x28) em uma matriz 1D. Em seguida, adicionamos uma camada densa com 128 neurônios e ativação ReLU. Finalmente, adicionamos uma camada de saída com 10 neurônios (correspondentes aos 10 dígitos) e ativação softmax.
Depois de definir o modelo, nós o compilamos usando o método compile. Especificamos o otimizador (neste caso, 'adam'), a função de perda ('sparse_categorical_crossentropy' para classificação multiclasse) e as métricas a serem avaliadas durante o treinamento.
Agora que temos nosso modelo definido e compilado, podemos prosseguir para treiná-lo no conjunto de dados MNIST. Usaremos o método fit para treinar o modelo.
# Train the model model.fit(X_train, Y_train, epochs= 10 , validation_data=(X_test, Y_test))
No código acima, passamos os dados de treinamento (X_train e Y_train) para o método fit junto com o número de épocas para treinar. Também fornecemos os dados de validação (X_test e Y_test) para avaliar o desempenho do modelo em dados não vistos durante o treinamento.
Depois de treinar o modelo, podemos fazer previsões usando o método predict:
# Make predictions predictions = model.predict(X_test)
No código acima, passamos os dados de teste (X_test) para o método predict e ele retorna as probabilidades previstas para cada classe.
Essa é uma breve visão geral da construção e treinamento de uma rede neural usando o Chaos no TensorFlow. Você pode explorar ainda mais diferentes camadas, funções de ativação, otimizadores e outros parâmetros para personalizar seu modelo.
técnicas e conceitos adicionais relacionados à construção e treinamento de redes neurais.
Técnicas de Regularização:
Dropout: Dropout é uma técnica de regularização usada para prevenir overfitting. Ele define aleatoriamente uma fração de unidades de entrada como 0 em cada atualização durante o treinamento, o que ajuda a evitar que o modelo dependa muito de qualquer conjunto específico de recursos.
Regularização L1 e L2: A regularização L1 e L2 são técnicas usadas para adicionar uma penalidade à função de perda para evitar grandes pesos na rede. A regularização L1 adiciona o valor absoluto dos pesos à função de perda, incentivando a dispersão, enquanto a regularização L2 adiciona os pesos ao quadrado à função de perda, incentivando pesos pequenos.
Funções avançadas de ativação:
Leaky ReLU: Leaky ReLU é uma função de ativação que resolve o problema de "morrer ReLU" permitindo uma pequena inclinação para entradas negativas. Ele introduz uma pequena inclinação negativa quando a entrada é negativa, o que ajuda a evitar que os neurônios morram durante o treinamento.
Unidade Linear Exponencial (ELU): ELU é uma função de ativação que suaviza a saída para entradas negativas, permitindo que a ativação assuma valores negativos. Foi demonstrado que ajuda a melhorar o aprendizado de redes neurais e reduz o viés para valores positivos.
Swish: Swish é uma função de ativação que realiza uma interpolação suave entre as funções linear e sigmoide. Foi demonstrado que fornece melhores resultados em comparação com outras funções de ativação, como ReLU e sigmóide em certos casos.
Transfer Learning: Transfer Learning é uma técnica que utiliza modelos pré-treinados para resolver novas tarefas ou melhorar o desempenho de um modelo em uma tarefa relacionada. Em vez de treinar um modelo do zero, você pode usar um modelo pré-treinado como ponto de partida e ajustá-lo em sua tarefa ou conjunto de dados específico. Isso é particularmente útil quando você tem dados limitados para sua tarefa específica.
Ajuste de hiperparâmetros: Hiperparâmetros são parâmetros que não são aprendidos pelo modelo, mas afetam o processo de aprendizado, como taxa de aprendizado, tamanho do lote, número de camadas, etc. O ajuste desses hiperparâmetros pode afetar significativamente o desempenho do modelo. Técnicas como pesquisa em grade, pesquisa aleatória e otimização bayesiana podem ser usadas para pesquisar sistematicamente o espaço de hiperparâmetros e encontrar a melhor combinação.
Avaliação do Modelo: Avaliar o desempenho de um modelo é crucial para avaliar sua eficácia. Métricas de avaliação comuns para tarefas de classificação incluem exatidão, precisão, recuperação, pontuação F1 e área sob a curva característica de operação do receptor (ROC AUC). É importante escolher as métricas apropriadas com base no problema em questão e na natureza dos dados.
Tratamento de conjuntos de dados desbalanceados: conjuntos de dados desbalanceados ocorrem quando a distribuição de classes não é igual, o que pode levar a modelos tendenciosos. Técnicas como superamostragem da classe minoritária, subamostragem da classe majoritária ou o uso de uma combinação de ambas podem ajudar a resolver esse problema. Além disso, a utilização de métricas de avaliação como precisão, recall e pontuação F1 pode fornecer uma melhor compreensão do desempenho do modelo em conjuntos de dados desequilibrados.
Lembre-se, construir e treinar redes neurais é um processo iterativo. Envolve experimentação, ajuste fino e melhoria contínua para alcançar os resultados desejados.
Carregando seus próprios dados - Fundamentos do Deep Learning com Python, TensorFlow e Keras p.2
Carregando seus próprios dados - Fundamentos do Deep Learning com Python, TensorFlow e Keras p.2
Bem-vindo, pessoal, à parte 2 do nosso tutorial de aprendizagem profunda sobre Python TensorFlow em Karros. Neste tutorial, vamos nos concentrar em carregar um conjunto de dados externo. Especificamente, usaremos o conjunto de dados de cães e gatos da Microsoft, originalmente um desafio do Kaggle. O objetivo é treinar uma rede neural para identificar se uma imagem contém um gato ou um cachorro.
Para começar, baixe o conjunto de dados de cães e gatos da Microsoft. Depois de baixar e extrair o conjunto de dados, você verá dois diretórios: "cat" e "dog". Esses diretórios contêm imagens de gatos e cachorros, respectivamente. Cada diretório deve ter um número substancial de amostras, em torno de 12.500, fornecendo exemplos amplos para o treinamento de nosso modelo.
Agora vamos passar para a parte de codificação. Precisamos importar várias bibliotecas: numpy como np, matplotlib.pyplot como plt e OpenCV como cv2. Se você não tiver essas bibliotecas instaladas, poderá usar o pip para instalá-las.
Em seguida, definiremos o diretório de dados onde nosso conjunto de dados está localizado. Você pode especificar o caminho para seu conjunto de dados de acordo. Também definiremos as categorias como "cachorro" e "gato" para corresponder aos diretórios em nosso conjunto de dados.
Iremos iterar cada categoria e as imagens correspondentes usando a biblioteca do sistema operacional. Para cada imagem, vamos convertê-la em tons de cinza usando a biblioteca cv2. Escolhemos a escala de cinza porque acreditamos que a cor não é crucial para diferenciar cães e gatos nessa tarefa específica.
Para visualizar as imagens, usaremos o matplotlib.pyplot. Mostraremos uma imagem de exemplo usando plt.imshow e o mapa de cores em tons de cinza. Esta etapa nos permite confirmar se as imagens foram carregadas corretamente.
Depois de verificar as imagens, iremos redimensioná-las para uma forma uniforme. Precisamos decidir sobre um tamanho de destino, como 50 x 50 pixels, para garantir a consistência. Vamos redimensionar as imagens usando a função cv2.resize e armazenar as matrizes de imagens redimensionadas.
Agora, vamos criar o conjunto de dados de treinamento. Inicializamos uma lista vazia chamada "training_data" e definimos uma função chamada "create_training_data". Nessa função, iteramos pelas imagens e atribuímos rótulos numéricos (0 para cachorros, 1 para gatos) usando o índice da categoria na lista "categorias".
Para cada imagem, redimensionamos para o tamanho de destino escolhido. Anexamos a matriz de imagem redimensionada e seu rótulo correspondente à lista training_data. Também lidamos com possíveis exceções relacionadas a imagens quebradas no conjunto de dados.
Depois de criar o conjunto de dados de treinamento, devemos verificar o equilíbrio dos dados. Em uma tarefa de classificação binária como esta, é essencial ter um número igual de amostras para cada classe (50% cães e 50% gatos). Dados desequilibrados podem levar a previsões de modelo enviesadas. Se seus dados estiverem desequilibrados, você pode usar pesos de classe durante o treinamento para atenuar esse problema.
Para garantir a aleatoriedade e evitar que o modelo aprenda a ordem das imagens, embaralhamos os dados de treinamento usando a função random.shuffle.
Agora que nossos dados estão embaralhados, podemos empacotá-los em variáveis para recursos (X) e rótulos (Y). Inicializamos listas vazias para X e Y e iteramos pelos dados de treinamento, anexando os recursos e rótulos às respectivas listas. Por fim, convertemos X em uma matriz NumPy e a remodelamos usando np.array e a forma de cada recurso.
Neste ponto, preparamos nossos dados para treinar a rede neural. Agora estamos prontos para prosseguir com outras etapas, como dividir os dados em conjuntos de treinamento e validação, construir o modelo e treiná-lo usando o TensorFlow.
Negativo 1 é um espaço reservado que calcula automaticamente o tamanho com base no comprimento da matriz e na forma de cada elemento. Portanto, neste caso, estamos remodelando a matriz X para ter uma forma de (-1, image_size, image_size). Isso garante que os dados estejam no formato correto para serem alimentados na rede neural.
Em seguida, precisamos normalizar os valores de pixel das imagens. Atualmente, os valores de pixel variam de 0 a 255, representando a intensidade da escala de cinza. As redes neurais geralmente funcionam melhor quando os dados de entrada são normalizados, o que significa que os valores são dimensionados para um intervalo menor. Podemos conseguir isso dividindo os valores de pixel por 255,0, que os escalará entre 0 e 1,0. Isso pode ser feito usando o seguinte código:
x = x / 255.0
Redes neurais convolucionais - Noções básicas de Deep Learning com Python, TensorFlow e Keras p.3
Redes neurais convolucionais - Noções básicas de Deep Learning com Python, TensorFlow e Keras p.3
Olá a todos, e bem-vindos à terceira parte da nossa série de tutoriais Deep Learning com Python, TensorFlow e Keras. Neste vídeo, vamos nos concentrar em redes neurais convolucionais (CNNs) e como aplicá-las para classificar cães versus gatos usando o conjunto de dados que construímos no vídeo anterior.
Antes de mergulharmos nas CNNs, vamos abordar rapidamente como elas funcionam e por que são úteis para dados de imagem. As CNNs envolvem várias etapas: convolução, agrupamento e, em seguida, mais convolução e agrupamento. A ideia principal por trás da convolução é extrair recursos úteis de uma imagem. Usamos uma janela convolucional, normalmente representada como uma matriz (por exemplo, 3x3), para escanear a imagem e simplificar as informações dentro da janela para um único valor. A janela então muda e repete esse processo várias vezes. A passada, que determina o quanto a janela se move, também pode ser ajustada.
Com o Keras, podemos especificar o tamanho da janela e a maioria dos outros detalhes são resolvidos automaticamente. Se você quiser se aprofundar nas complexidades do aprendizado profundo, recomendo verificar a série de tutoriais "Aprendizado de máquina prático", onde o funcionamento interno é explicado com mais detalhes, principalmente para o código bruto do TensorFlow.
A saída da camada convolucional é um conjunto de recursos extraídos da imagem. Esses recursos são normalmente passados por uma camada de agrupamento, sendo o tipo mais comum o agrupamento máximo. O pooling máximo seleciona o valor máximo dentro de uma janela e o desloca repetidamente, reduzindo efetivamente a resolução dos dados.
A ideia de alto nível por trás das CNNs é que elas gradualmente extraem recursos mais complexos da imagem à medida que você se aprofunda na rede. As camadas iniciais podem identificar arestas e linhas, enquanto as camadas mais profundas podem reconhecer formas mais complexas, como círculos ou quadrados. Eventualmente, a rede pode aprender a identificar objetos ou padrões específicos.
Para implementar uma CNN, precisamos importar as bibliotecas necessárias. Importamos o TensorFlow e os módulos Keras que usaremos, como Sequential, Dense, Dropout, Activation, Conv2D e MaxPooling2D. Também importamos pickle para carregar nosso conjunto de dados.
Antes de alimentar os dados na rede neural, devemos considerar normalizá-la. Em nosso caso, podemos dimensionar os dados de pixel dividindo-os por 255, já que os valores de pixel variam de 0 a 255. Alternativamente, podemos usar a função normalize de caos.utils para cenários de normalização mais complexos.
Em seguida, começamos a construir nosso modelo usando a API Sequential. Adicionamos uma camada Conv2D com 64 unidades e um tamanho de janela 3x3. O input_shape é definido dinamicamente usando X.shape. Em seguida, adicionamos uma camada de ativação usando a função de ativação linear retificada (ReLU). Em seguida, adicionamos uma camada de pool máximo com um tamanho de janela de 2x2.
Repetimos esse processo adicionando outra camada Conv2D e uma camada de pool máximo correspondente. Neste ponto, temos uma rede neural convolucional 2D.
Para passar os recursos extraídos para uma camada totalmente conectada, precisamos achatar os dados. Adicionamos uma camada Flatten antes de adicionar uma camada final Dense com 64 nós. Por fim, adicionamos uma camada de saída com um único nó e especificamos a função de ativação, que pode ser categórica ou binária.
Compilamos o modelo especificando a função de perda (entropia cruzada categórica ou binária), o otimizador (por exemplo, Adam) e as métricas para avaliar o desempenho do modelo (por exemplo, precisão).
Para treinar o modelo, usamos o método fit, passando nossos dados de entrada X e rótulos Y. Também podemos especificar o tamanho do lote (por exemplo, 32).
Usaremos o seguinte código para treinar o modelo:
model.fit(X, Y, batch_size= 32 , validation_split= 0.1 )
Esse código treinará o modelo usando os dados de entrada X e os rótulos correspondentes Y. Definimos o tamanho do lote como 32, o que significa que o modelo processará 32 amostras por vez durante o treinamento. O parâmetro validação_split é definido como 0,1, o que significa que 10% dos dados serão usados para validação durante o treinamento do modelo.
Depois que o modelo é treinado, podemos avaliar seu desempenho usando os dados de teste. Podemos usar o seguinte código para avaliar o modelo:
model.evaluate(X_test, Y_test)
Aqui, X_test e Y_test representam os dados e rótulos de teste, respectivamente. Este código retornará o valor da perda e a precisão do modelo nos dados de teste.
Depois de avaliar o modelo, podemos usá-lo para fazer previsões sobre dados novos e não vistos. Podemos usar a função predict() para obter os rótulos previstos para os novos dados. Aqui está um exemplo:
predictions = model.predict(X_new)
predicted_labels = np.argmax(predictions, axis= 1 )
É isso! Agora você treinou um modelo de rede neural convolucional para classificar cães e gatos e o usou para fazer previsões sobre novos dados. Lembre-se de salvar o modelo treinado para uso futuro, se necessário.
Analisando modelos com TensorBoard - Deep Learning com Python, TensorFlow e Keras p.4
Analisando modelos com TensorBoard - Deep Learning com Python, TensorFlow e Keras p.4
Sejam todos bem-vindos à parte 4 da série de tutoriais "Deep Learning with Python: TensorFlow and Keras". Neste vídeo e no próximo, discutiremos como analisar e otimizar nossos modelos usando o TensorBoard. TensorBoard é uma ferramenta poderosa que nos permite visualizar o treinamento de nossos modelos ao longo do tempo. Seu principal objetivo é nos ajudar a entender vários aspectos do desempenho de nosso modelo, como precisão, precisão de validação, perda e perda de validação. Além disso, existem recursos mais avançados no TensorBoard que podemos explorar em tutoriais futuros.
Antes de mergulharmos no TensorBoard, vamos abordar um pequeno detalhe. Embora não seja crucial para este tutorial, quero ressaltar que mesmo modelos pequenos tendem a consumir uma quantidade significativa de memória da GPU. Se você planeja executar vários modelos simultaneamente, pode especificar uma fração da memória da GPU que cada modelo deve usar. Ao fazer isso, você pode evitar possíveis problemas ao executar vários modelos ou encontrar restrições de memória. Por exemplo, normalmente defino o modelo para usar um terço da memória da GPU. Essa abordagem provou ser útil ao executar vários modelos simultaneamente, como na série "Python Plays GTA" envolvendo detecção de objetos e autocondução. É apenas uma dica útil que pode poupar algum tempo e dores de cabeça.
Agora, vamos prosseguir com o tópico principal. A primeira coisa que quero abordar é adicionar uma função de ativação após a camada densa. Foi um descuido da minha parte não incluí-lo inicialmente. Adicionar uma função de ativação é essencial porque sem ela, a camada densa torna-se uma função de ativação linear, o que não é adequado para nossos propósitos. Queremos evitar a regressão e garantir que nosso modelo tenha um desempenho ideal. Então, vamos consertar isso rapidamente inserindo a função de ativação antes da camada densa.
Com essa correção feita, devemos observar uma melhora significativa na precisão. Enquanto o modelo está treinando, vamos explorar a documentação do TensorFlow e aprender sobre os vários retornos de chamada do Keras disponíveis. No nosso caso, usaremos o retorno de chamada do TensorBoard para fazer a interface com o TensorBoard. No entanto, vale a pena notar que existem outros retornos de chamada úteis, como parada antecipada com base em parâmetros específicos, agendamento de taxa de aprendizado e ponto de verificação de modelo. O ponto de verificação do modelo é particularmente valioso quando você deseja salvar o modelo em intervalos específicos, como a melhor perda ou precisão de validação. Por enquanto, vamos nos concentrar no retorno de chamada do TensorBoard, mas posso abordar brevemente outros retornos de chamada em um vídeo futuro.
Para usar o callback do TensorBoard, precisamos importá-lo do módulo Keras callbacks do TensorFlow. Adicione a seguinte linha de código para importar o TensorBoard:
from tensorflow.keras.callbacks import TensorBoard
Agora que importamos o módulo necessário, vamos fazer algumas tarefas de limpeza. É sempre uma boa prática dar um nome significativo ao seu modelo, especialmente ao trabalhar com vários modelos. Nesse caso, podemos nomear nosso modelo como "cats_vs_dogs_CNN_64x2". Além disso, vamos adicionar um carimbo de data/hora ao nome para garantir exclusividade. Incluir o carimbo de data/hora é útil ao treinar novamente um modelo ou evitar qualquer confusão com as versões do modelo. Então, no início do nosso código, vamos definir o nome do modelo e o timestamp da seguinte forma:
import time model_name = f"cats_vs_dogs_CNN_64x2_ { int (time.time())} "
tensorboard_callback = TensorBoard(log_dir= f"logs/ {model_name} " )
Além disso, o tensor board nos permite analisar e otimizar nossos modelos, fornecendo visualizações do processo de treinamento. Ele se concentra principalmente em métricas como precisão, precisão de validação, perda e perda de validação. Essas métricas nos ajudam a entender o desempenho do nosso modelo ao longo do tempo e identificar áreas para melhoria. Embora a precisão e a perda sejam comumente monitoradas, o tensor board oferece funcionalidades mais avançadas que podemos explorar no futuro.
Para começar a usar o tensor board, primeiro precisamos fazer uma pequena adição ao nosso código. Embora não seja crucial para este tutorial, vale a pena mencionar. Adicionando algumas linhas de código, podemos alocar uma fração específica da memória da GPU para nosso modelo. Isso é benéfico ao executar vários modelos simultaneamente ou ao encontrar problemas com VRAM. Isso nos permite controlar a alocação da GPU e evitar possíveis travamentos ou estouro de memória. No nosso caso, alocamos um terço da GPU para o modelo. Isso garante uma execução suave e evita conflitos ao trabalhar com outros modelos ou projetos.
Seguindo em frente, vamos nos concentrar na implementação do tensor board. Primeiramente, precisamos importar as dependências necessárias. Importamos o módulo "tensorboard" do pacote "tensorflow.keras.callbacks". Este módulo fornece a funcionalidade de retorno de chamada para a placa do tensor.
Em seguida, queremos atribuir um nome significativo ao nosso modelo. Dar a cada modelo um nome distinto é essencial ao trabalhar com vários modelos. Isso nos ajuda a acompanhar os experimentos e evitar qualquer confusão. Nesse caso, nomeamos nosso modelo "cat's_first_dog_CNN_64x2_good_enough". Além disso, adicionamos um carimbo de data/hora ao nome usando o valor de hora atual. Isso garante exclusividade e evita qualquer substituição acidental de modelos.
Depois de nomear nosso modelo, podemos definir o objeto de callback da placa do tensor. Criamos uma instância da classe "TensorBoard" e atribuímos à variável "tensorboard". Passamos o caminho do diretório de log para o construtor. O diretório de log é onde o tensor board armazenará os logs e dados relacionados ao nosso modelo. Usamos formatação de string para incluir o nome do modelo no caminho do diretório de log.
Assim que tivermos o objeto callback pronto, podemos incorporá-lo ao nosso processo de treinamento do modelo. No método "fit" do nosso modelo, passamos o objeto callback para o parâmetro "callbacks" como uma lista. Nesse caso, temos apenas um retorno de chamada, que é o retorno de chamada da placa do tensor. No entanto, vale a pena observar que você pode incluir vários retornos de chamada na lista, se necessário.
Com o retorno de chamada integrado, agora podemos treinar nosso modelo. Definimos o número de épocas como 10 para este exemplo. No entanto, sinta-se à vontade para ajustar o número de épocas com base em seus requisitos. À medida que o modelo treina, o tensor board começa a gerar logs e visualizações com base nas métricas especificadas.
Para visualizar a placa do tensor em ação, precisamos abrir a janela de comando ou terminal e navegar até o diretório que contém os arquivos de log. Uma vez no diretório correto, executamos o comando tensor board digitando "tensorboard --logdir logs" no prompt de comando. Este comando inicia o servidor do tensor board e fornece uma URL local onde podemos acessar a interface do tensor board.
Depois de iniciar o tensor board, podemos abrir um navegador da Web e inserir a URL fornecida pelo prompt de comando. Isso exibirá a interface do tensor board, onde podemos visualizar o progresso do treinamento do nosso modelo. A interface mostra vários gráficos, incluindo precisão dentro da amostra, perda dentro da amostra, precisão fora da amostra e perda fora da amostra. Analisamos essas métricas para monitorar o desempenho do modelo e tomar decisões informadas sobre sua otimização.
Ao observar os gráficos, podemos identificar padrões e tendências no comportamento do modelo. Por exemplo, se a perda de validação começar a aumentar enquanto a precisão da validação permanecer estável ou diminuir, isso indica overfitting. Por outro lado, se a precisão e a perda da validação melhorarem com o tempo, isso sugere que o modelo está aprendendo de forma eficaz.
A placa Tensor fornece uma plataforma poderosa para analisar e otimizar modelos. Suas visualizações oferecem informações valiosas sobre o processo de treinamento e facilitam a tomada de decisões. Aproveitando o tensor board, podemos agilizar o processo de desenvolvimento do modelo e obter melhores resultados.
Na próxima parte desta série de tutoriais, vamos nos aprofundar nos recursos avançados do tensor board, incluindo histogramas, distribuições e incorporações. Esses recursos fornecem maior granularidade e nos permitem obter uma compreensão mais abrangente de nossos modelos. Fique ligado no próximo vídeo, onde exploramos esses recursos empolgantes.
É isso para este tutorial. Obrigado por assistir, e vejo vocês no próximo vídeo!
Otimizando com TensorBoard - Deep Learning com Python, TensorFlow e Keras p.5
Otimizando com TensorBoard - Deep Learning com Python, TensorFlow e Keras p.5
Olá a todos e bem-vindos à Parte Cinco da série de tutoriais Deep Learning with Python TensorBoard and Keras. Neste tutorial, vamos nos concentrar no TensorBoard e em como podemos usá-lo para otimizar modelos visualizando diferentes tentativas de modelo. Vamos mergulhar nisso!
Primeiro, vamos analisar o modelo e identificar os aspectos que podemos ajustar para melhorar seu desempenho. Embora nosso modelo atual tenha alcançado cerca de 79% de precisão, acreditamos que podemos fazer melhor. Algumas áreas potenciais para otimização incluem o otimizador, taxa de aprendizado, número de camadas densas, unidades por camada, unidades de ativação, tamanho do kernel, passo, taxa de decaimento e muito mais. Com inúmeras opções para explorar, podemos acabar testando milhares de modelos. Então por onde começamos?
Para facilitar as coisas, vamos começar com as modificações mais simples. Vamos nos concentrar em ajustar o número de camadas, nós por camada e incluir ou não uma camada densa no final. Para o número de camadas densas, vamos considerar zero, um ou dois. Com relação aos tamanhos de camada, usaremos valores de 32, 64 e 128. Esses valores são apenas convenções e você pode escolher valores diferentes de acordo com suas preferências.
Agora, vamos implementar essas alterações em nosso código. Definiremos algumas variáveis para as escolhas que queremos fazer, como o número de camadas densas e os tamanhos das camadas. Faremos uma iteração por meio dessas variáveis para criar diferentes combinações de modelos. Além disso, criaremos um nome para cada modelo que reflita sua configuração.
Assim que tivermos as configurações do modelo, podemos aplicá-las em nosso código. Atualizaremos a estrutura do modelo de acordo, considerando a forma de entrada, camadas convolucionais, camadas densas e camada de saída. Também garantiremos que os tamanhos das camadas sejam ajustados adequadamente.
Com todas as alterações feitas, é hora de executar o código. No entanto, como o treinamento de vários modelos pode ser demorado, já executei o código e salvei os resultados. Vamos analisar os resultados usando o TensorBoard.
Carregamos os logs do TensorBoard e observamos as diferentes combinações de modelos. Os modelos são organizados com base em seu desempenho, especificamente a perda de validação. Nós nos concentramos nos modelos de melhor desempenho e observamos suas configurações.
A partir dos resultados, torna-se evidente que os modelos com três camadas convolucionais e zero camadas densas apresentam bom desempenho de forma consistente. O número específico de nós por camada parece menos significativo. No entanto, vale a pena observar que camadas densas maiores, como 512 ou 256 nós, podem gerar resultados ainda melhores. Para verificar isso, você pode testar diferentes tamanhos de camada densa.
Para resumir, começamos explorando várias configurações de modelo usando o TensorBoard. Descobrimos que os modelos com três camadas convolucionais e sem camadas densas tiveram um bom desempenho de forma consistente. Também identificamos que o número de nós por camada poderia ser ainda mais otimizado. Ao testar diferentes tamanhos de camadas densas, podemos melhorar ainda mais a precisão do modelo.
Lembre-se de que este é apenas um ponto de partida e há muitos outros aspectos que você pode ajustar para otimizar seus modelos. O TensorBoard fornece uma ferramenta valiosa para visualizar e analisar essas variações de modelo, ajudando você a tomar decisões informadas para melhoria do modelo.
Como usar seu modelo treinado - Noções básicas de Deep Learning com Python, TensorFlow e Keras p.6
Como usar seu modelo treinado - Noções básicas de Deep Learning com Python, TensorFlow e Keras p.6
Olá a todos e bem-vindos à Parte 6 da série de tutoriais Deep Learning em Python com TensorFlow e Keras!
Neste vídeo, discutiremos como usar nosso modelo treinado para fazer previsões sobre novas imagens. Muitas pessoas têm perguntado sobre isso, pois treinaram e testaram com sucesso seus conjuntos de dados, mas não têm certeza de como usar o modelo para prever imagens externas. Então, vamos mergulhar nisso!
Primeiro, precisamos importar as bibliotecas necessárias. Importaremos cv2 para processamento de imagem e tensorflow como TF para trabalhar com nosso modelo. Também precisaremos da lista de categorias, que contém os rótulos de classe "cachorro" e "gato" que usamos durante o treinamento.
Em seguida, definiremos uma função chamada prepare que recebe um caminho de arquivo como parâmetro. Esta função irá lidar com as etapas de pré-processamento necessárias para a imagem de entrada. Vamos redimensionar a imagem para um tamanho específico e convertê-la em tons de cinza. A imagem será retornada como uma matriz numpy reformulada.
Depois disso, carregaremos nosso modelo treinado usando a função TF.keras.models.load_model(). Anteriormente, salvamos nosso modelo como um "modelo CNN 64 por 3", então vamos carregá-lo usando o mesmo nome.
Agora, estamos prontos para fazer previsões. Definiremos uma variável chamada predição e atribuiremos a ela o resultado da chamada de model.predict() em nossa imagem preparada. É importante observar que o método predict() espera uma lista como entrada, mesmo se estivermos prevendo em uma única imagem. Então, precisamos passar a imagem preparada como uma lista.
Assim que tivermos o resultado da previsão, podemos imprimi-lo. No entanto, a previsão está atualmente na forma de uma lista aninhada. Para torná-lo mais legível, podemos converter o valor de previsão em um número inteiro e usá-lo como um índice para recuperar o rótulo de classe correspondente da lista de categorias.
Por fim, podemos imprimir o rótulo da classe prevista, que representa se a imagem é classificada como cachorro ou gato.
Neste tutorial, usamos duas imagens externas para testar nosso modelo: uma de um cachorro com um cone de vergonha e outra de uma criatura desconhecida. Essas imagens não faziam parte do nosso conjunto de dados de treinamento, garantindo que estamos fazendo previsões sobre dados não vistos.
Para experimentá-lo com suas próprias imagens de cães e gatos, siga as etapas descritas no código. Lembre-se de que a precisão pode variar, mas, em média, deve ficar em torno de 80%.
É tudo por agora! Quero agradecer aos nossos patrocinadores recentes: Michael, Nick, Rodrigo e Papasan E. Seu apoio é muito apreciado. Se você tiver dúvidas, comentários ou sugestões para futuros tutoriais, deixe-os abaixo. Também estou aberto a ideias para usar redes neurais recorrentes, então, se você tiver um conjunto de dados simples em mente, me avise.
Vejo você no próximo tutorial, onde exploraremos redes neurais recorrentes. Até então, codificação feliz!
Redes neurais recorrentes (RNN) - Deep Learning com Python, TensorFlow e Keras p.7
Redes neurais recorrentes (RNN) - Deep Learning com Python, TensorFlow e Keras p.7
Olá a todos, e bem-vindos à Parte 7 da série de tutoriais Deep Learning with Python TensorFlow in Chaos. Nesta parte, estaremos focando na rede neural recorrente (RNN). O propósito de uma RNN é capturar o significado e a importância da ordem dos dados. Isso é particularmente relevante em dados de séries temporais, em que os dados são organizados temporalmente, e em processamento de linguagem natural, em que a ordem das palavras em uma frase carrega significado.
Para ilustrar o conceito, vamos considerar o exemplo de uma frase: "Algumas pessoas criaram uma rede neural". Quando essa frase é processada por uma rede neural profunda, que normalmente tokeniza os dados dividindo-os em palavras individuais, a rede pode falhar em capturar o significado correto. Por exemplo, a frase "Uma rede neural criou algumas pessoas" tem um significado completamente diferente. Isso enfatiza a importância da ordem das palavras na determinação do significado de uma frase.
Agora, vamos nos aprofundar no funcionamento de uma rede neural recorrente. O bloco de construção básico de uma RNN é a célula recorrente, que geralmente é implementada usando uma célula de memória de longo prazo (LSTM). Embora existam outras opções como a unidade recorrente fechada (GRU), a célula LSTM é comumente usada. Em uma RNN, cada célula recebe dados sequenciais como entrada e saída para a próxima camada ou a próxima célula na camada recorrente.
A saída de uma célula pode ser direcionada de diferentes maneiras. Pode ir para a próxima camada ou para a próxima célula de maneira unidirecional ou bidirecional. Neste tutorial, vamos nos concentrar em uma RNN unidirecional básica. Para ilustrar isso, imagine uma caixa verde representando uma célula recorrente. Os dados da célula anterior entram na célula atual, que executa operações como esquecer informações irrelevantes do nó anterior, incorporar novos dados de entrada e decidir quais informações enviar para a próxima camada ou nó.
Para visualizar melhor este processo, vamos considerar uma célula específica na camada. A caixa verde representa a célula atual. Os dados fluem da célula anterior, envolvem e entram na célula LSTM. Dentro da célula, existem operações para esquecer informações do nó anterior, incorporar novos dados de entrada e determinar a saída a ser passada para a próxima camada ou nó. Essas operações coletivamente permitem que a célula LSTM retenha informações importantes e as transmita para as camadas ou nós subsequentes.
A implementação de uma RNN pode ser complexa, especialmente ao lidar com valores escalares. Se você estiver interessado em uma explicação detalhada de como as células LSTM funcionam, recomendo verificar um guia abrangente que as explica em profundidade. Incluí um link para este guia na versão em texto do tutorial para sua referência.
Agora, vamos construir uma rede neural recorrente básica. Neste tutorial, começaremos com um exemplo simples usando o conjunto de dados M-NIST. No próximo tutorial, trabalharemos com dados de séries temporais mais realistas, focando especificamente nos preços das criptomoedas.
Para começar, vamos importar as bibliotecas necessárias. Importaremos o TensorFlow como tf, o modelo sequencial de tensorflow.keras.models, a camada densa de tensorflow.keras.layers, bem como as células Dropout e LSTM. Observe que, se você estiver usando a versão GPU do TensorFlow, também há uma célula LSTM otimizada chamada célula KU DNN LSTM. No entanto, para este tutorial, vamos nos ater à célula LSTM regular. Se você estiver usando a versão da CPU do TensorFlow, o cálculo pode levar um tempo significativo.
Em seguida, precisamos carregar o conjunto de dados. Para este exemplo, usaremos o conjunto de dados M-NIST. Podemos carregá-lo facilmente usando a função tf.keras.datasets.mnist.load_data(), que retorna os dados de treinamento e teste. Vamos descompactar os dados em variáveis: X_train, Y_train, X_test e Y_test.
Primeiro, vamos normalizar os dados de entrada dividindo cada valor de pixel por 255. Isso dimensionará os valores de pixel para um intervalo entre 0 e 1, adequado para treinamento de rede neural. Podemos conseguir isso dividindo os dados de treinamento e teste por 255.
X_train = X_train / 255.0 X_test = X_test / 255.0
Em seguida, precisamos converter os rótulos de destino em vetores codificados one-hot. No conjunto de dados M-NIST, os rótulos são números inteiros que variam de 0 a 9, representando os dígitos. A codificação one-hot converte cada rótulo em um vetor binário de comprimento 10, onde o índice correspondente ao dígito é definido como 1 e todos os outros índices são definidos como 0. Podemos usar a função to_categorical de tensorflow.keras.utils para executar uma -codificação quente.
Y_train = to_categorical(Y_train, num_classes=10)
Y_test = to_categorical(Y_test, num_classes=10)
Agora, vamos definir a arquitetura da nossa rede neural recorrente. Usaremos o modelo sequencial de tensorflow.keras.models e adicionaremos camadas a ele.
from tensorflow.keras.layers import LSTM, Dense
model = Sequential()
model.add(LSTM(128, input_shape=(X_train.shape[1:]), activation='relu', return_sequences=True))
model.add(Dropout(0.2))
model.add(LSTM(128, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
Agora, vamos compilar o modelo especificando a função de perda, o otimizador e a métrica de avaliação.
model. compile (loss= 'categorical_crossentropy' , optimizer= 'adam' , metrics=[ 'accuracy' ])
Por fim, vamos treinar o modelo usando os dados de treinamento e avaliá-lo nos dados de teste.
model.fit(X_train, Y_train, batch_size= 32 , epochs= 10 , validation_data=(X_test, Y_test))
É isso! Agora você construiu uma rede neural recorrente usando células LSTM para o conjunto de dados M-NIST. Você pode experimentar diferentes arquiteturas, hiperparâmetros e conjuntos de dados para explorar ainda mais os recursos das RNNs.
Introdução RNN de previsão de criptomoedas - Deep Learning com Python, TensorFlow e Keras p.8
Introdução RNN de previsão de criptomoedas - Deep Learning com Python, TensorFlow e Keras p.8
Olá a todos e bem-vindos a outro vídeo tutorial de aprendizado profundo com Python. Neste vídeo e nos próximos, discutiremos como aplicar uma rede neural recorrente (RNN) a um exemplo mais realista de trabalho com dados sequenciais. Especificamente, trabalharemos com um conjunto de dados de série temporal que consiste em preços e volumes de criptomoedas.
Antes de entrarmos nos detalhes, quero esclarecer que você pode aplicar os mesmos conceitos a outros tipos de dados sequenciais, como preços de ações ou dados de sensores. Assim, mesmo que você não esteja interessado em finanças, você ainda pode acompanhar e entender os conceitos.
O objetivo deste tutorial é usar uma rede neural recorrente para prever o preço futuro de uma criptomoeda com base em seu preço e volume anteriores. Vamos nos concentrar em quatro grandes criptomoedas: Bitcoin, Litecoin, Ethereum e Bitcoin Cash. A ideia é pegar os últimos 60 minutos de dados de preço e volume para cada uma dessas criptomoedas e usá-los como entrada para prever o preço do Litecoin, por exemplo, três minutos no futuro.
Esse tipo de problema de previsão também pode ser aplicado a outros domínios, como prever falhas de servidor ou tráfego de sites com base no tempo e nos dados de uso. O objetivo final é prever uma classificação (por exemplo, se o preço aumentará ou cairá) ou realizar uma regressão (por exemplo, prever o preço real ou a variação percentual).
Trabalhar com dados sequenciais apresenta desafios únicos. Primeiramente, precisamos pré-processar os dados e convertê-los em sequências que a rede neural recorrente possa manipular. Além disso, precisamos equilibrar e normalizar os dados, considerando que os preços e volumes de diferentes criptomoedas podem ter escalas diferentes. Dimensionar os dados é mais complexo do que em outros domínios, como dados de imagem, onde simplesmente dividimos por 255.
Além disso, avaliar o desempenho do modelo usando dados fora da amostra é um desafio diferente quando se trabalha com dados sequenciais. Há vários aspectos que precisamos cobrir, incluindo preparação de dados, normalização e avaliação.
Para começar, forneci um conjunto de dados para download. Você pode encontrar o link para download na descrição do tutorial. Depois de extrair o arquivo zip baixado, você encontrará quatro arquivos, cada um correspondendo aos dados de preço e volume de uma criptomoeda.
Usaremos a biblioteca pandas em Python para ler e manipular o conjunto de dados. Se você não tiver o pandas instalado, poderá fazê-lo executando o comando pip install pandas em seu terminal ou prompt de comando.
Em seguida, leremos o conjunto de dados usando pandas e examinaremos os dados. Vamos nos concentrar nas colunas de preço e volume de "fechamento" para cada criptomoeda. Para mesclar os dados de diferentes arquivos, definiremos a coluna "time" como o índice para cada dataframe. Em seguida, juntaremos os dataframes com base em seu índice compartilhado.
Assim que tivermos o dataframe mesclado, precisamos definir alguns parâmetros. Isso inclui o comprimento da sequência (o número de períodos passados a serem considerados), o período futuro (o número de períodos no futuro a prever) e a proporção a prever (a criptomoeda que queremos prever).
No nosso caso, vamos nos concentrar em prever o preço futuro do Litecoin (LTC) com base nos últimos 60 minutos de dados e prever três minutos no futuro. Também definiremos uma regra de classificação, onde classificamos a previsão como um aumento ou diminuição de preços com base nos preços atuais e futuros.
Com essas etapas iniciais concluídas, agora estamos prontos para pré-processar os dados, criar sequências e treinar a rede neural recorrente. Abordaremos esses tópicos nos próximos vídeos, portanto, fique atento.
Se você quiser acompanhar, certifique-se de baixar o conjunto de dados e configurar as bibliotecas necessárias. Você pode encontrar o código completo e as instruções na versão em texto do tutorial, que está disponível na descrição.
Temos muito a cobrir, então vamos classificá-lo como 1, indicando um aumento de preço. Caso contrário, se o preço futuro for menor que o preço atual, iremos classificá-lo como 0, indicando uma queda de preço. Esta é uma regra simples que estamos usando para classificação, mas você pode experimentar regras diferentes ou até mesmo usar a regressão para prever a alteração real do preço.
Agora, vamos criar a coluna de destino em nosso DataFrame principal. Usaremos a função shift dos pandas para deslocar os valores da coluna "LTCUSD_close" para o período futuro. Isso nos dará os preços futuros que compararemos com os preços atuais para determinar a classificação. Atribuiremos o resultado a uma nova coluna chamada "target".
main_df[ 'target' ] = main_df[ 'LTCUSD_close' ].shift(-future_period)
main_df.dropna(inplace= True )
Em seguida, vamos criar as sequências de entrada. Vamos iterar pelo DataFrame e criar sequências de comprimento sequence_length, consistindo nos preços e volumes anteriores de Bitcoin, Litecoin, Ethereum e Bitcoin Cash. Armazenaremos essas sequências em uma lista chamada "sequências".
for i in range(len(main_df) - sequence_length + 1):
sequence = main_df.iloc[i:i+sequence_length, 1:-1].values.flatten()
sequences.append(sequence)
Por fim, converteremos as sequências e alvos em matrizes numpy para facilitar a manipulação e o treinamento.
sequences = np.array(sequences)
targets = np.array(main_df['target'])
Observe que o código fornecido aqui é uma implementação parcial e se concentra nas etapas de pré-processamento de dados. Você precisará desenvolver ainda mais a arquitetura do modelo, treinar o modelo e avaliar seu desempenho. Além disso, pode ser necessário ajustar os hiperparâmetros e experimentar diferentes técnicas para melhorar a precisão do modelo.
Lembre-se de importar as bibliotecas necessárias, lidar com dados ausentes, pré-processar os recursos (normalização, dimensionamento etc.) e dividir os dados em conjuntos de treinamento e teste antes de treinar o modelo.
Espero que isso ajude você a entender o processo de trabalhar com dados sequenciais e aplicar redes neurais recorrentes para prever preços futuros. Boa sorte com seu projeto de aprendizado profundo!
Normalizando e criando sequências Crypto RNN - Deep Learning com Python, TensorFlow e Keras p.9
Normalizando e criando sequências Crypto RNN - Deep Learning com Python, TensorFlow e Keras p.9
Olá a todos, bem-vindos a mais um episódio da série de tutoriais Deep Learning with Python, TensorFlow e Chaos. Neste vídeo, continuaremos trabalhando em nosso miniprojeto de implementação de uma rede neural recorrente (RNN) para prever os movimentos futuros de preço de uma criptomoeda. Estaremos usando as sequências de preços e volumes da moeda, juntamente com três outros preços e volumes de criptomoedas.
Até agora, obtivemos os dados, os mesclamos e criamos os alvos. Agora, vamos para os próximos passos. Precisamos criar sequências a partir dos dados e executar tarefas como balanceamento, normalização e dimensionamento. No entanto, antes de mergulhar nessas tarefas, é crucial abordar a questão dos testes fora da amostra.
Ao lidar com dados temporais e de séries temporais, embaralhar e selecionar aleatoriamente uma parte como dados fora da amostra pode levar a um modelo tendencioso. Em nosso caso, com sequências de 60 minutos e uma janela de previsão de 3 minutos, selecionar aleatoriamente os dados fora da amostra pode resultar na presença de exemplos semelhantes nos conjuntos dentro e fora da amostra. Isso tornaria mais fácil para o modelo superajustar e ter um desempenho ruim em dados não vistos.
Para resolver isso, precisamos selecionar cuidadosamente os dados fora da amostra. Para dados de séries temporais, é recomendável escolher um bloco de dados do futuro como o conjunto fora da amostra. Em nosso caso, consideraremos os últimos 5% dos dados históricos como nossos dados fora da amostra. Essa abordagem simula a construção do modelo 5% do tempo anterior e o teste futuro.
Agora, vamos implementar essa separação de dados fora da amostra. Classificaremos os dados com base no registro de data e hora e encontraremos o limite dos últimos 5% das vezes. Ao separar os dados dessa maneira, garantimos que o conjunto fora da amostra contenha dados do futuro, evitando vazamento de dados e testes tendenciosos. Uma vez separados, teremos os dados de validação e os dados de treinamento.
Antes de prosseguir, é importante observar que precisamos pré-processar os dados de validação e treinamento. Vamos criar sequências, equilibrar os dados, normalizá-los, dimensioná-los e realizar outras tarefas necessárias. Para simplificar esse processo, vamos criar uma função chamada preprocess_df que recebe um DataFrame como entrada e executa todas essas etapas de pré-processamento.
Primeiro, importamos o módulo de pré-processamento da biblioteca sklearn. Se você não o tiver instalado, poderá fazê-lo executando pip install sklearn. Em seguida, definimos a função preprocess_df que recebe um DataFrame como parâmetro.
Dentro da função, começamos descartando a coluna futura desnecessária do DataFrame. Em seguida, iteramos sobre as colunas do DataFrame e aplicamos a transformação de alteração percentual. Essa etapa de normalização ajuda a lidar com diferentes magnitudes de preços e volumes em criptomoedas.
Depois de normalizar os dados, descartamos todas as linhas que contêm valores NaN, pois podem causar problemas durante o treinamento. Em seguida, usamos a função preprocessing.scale para dimensionar os valores entre 0 e 1. Como alternativa, você pode implementar sua própria lógica de dimensionamento.
Agora que pré-processamos os dados, vamos passar para o tratamento de dados sequenciais. Criamos uma lista vazia chamada sequencial_data e inicializamos um objeto deque chamado prev_days com um comprimento máximo de 60. O objeto deque nos permite anexar novos itens com eficiência e remover automaticamente os antigos quando atinge o comprimento máximo.
Em seguida, iteramos sobre os valores do DataFrame, que agora contém os dados normalizados e dimensionados. Para cada linha, anexamos os valores ao deque prev_days. Assim que o deque atinge um comprimento de pelo menos 60, começamos a preencher o sequence_data
# Create a deque object with a maximum length of max_len
if len(prev_days) < max_len:
prev_days.append([n for n in i[:-1]])
else:
# Append the current values to prev_days
prev_days.append([n for n in i[:-1]])
# Add the sequence to the sequential_data list
sequential_data.append([np.array(prev_days), i[-1]])
# Remove the oldest sequence from prev_days
prev_days.popleft()
Agora que geramos as sequências, podemos prosseguir com o balanceamento dos dados. O balanceamento é importante para evitar qualquer tendência para uma classe específica em nossos dados de treinamento. Neste caso, nossas classes são os diferentes movimentos de preços (para cima ou para baixo). Para equilibrar os dados, contaremos o número de ocorrências para cada classe e limitaremos o número de sequências da classe majoritária para corresponder à classe minoritária.
sells = []
for seq, target in sequential_data:
if target == 0:
sells.append([seq, target])
elif target == 1:
buys.append([seq, target])
# Determine the minimum number of sequences in buys and sells
lower = min(len(buys), len(sells))
# Balance the data by randomly selecting the required number of sequences from buys and sells
buys = buys[:lower]
sells = sells[:lower]
# Concatenate buys and sells to create balanced_data
balanced_data = buys + sells
# Shuffle the balanced_data
random.shuffle(balanced_data)
Depois de balancear os dados, podemos dividi-los em matrizes de recursos de entrada (X) e rótulos de destino (y).
y = []
for seq, target in balanced_data:
X.append(seq)
y.append(target)
# Convert X and y to numpy arrays
X = np.array(X)
y = np.array(y)
Agora que temos X como os recursos de entrada e y como os rótulos de destino, podemos continuar dividindo os dados em conjuntos de treinamento e validação.
train_x, val_x, train_y, val_y = train_test_split(X, y, test_size=0.2, random_state=42)
No código acima, usamos a função train_test_split do scikit-learn para dividir os dados em conjuntos de treinamento e validação. Atribuímos 80% dos dados ao conjunto de treinamento (train_x e train_y) e 20%
scaler = MinMaxScaler()
train_x = scaler.fit_transform(train_x.reshape(train_x.shape[0], -1))
val_x = scaler.transform(val_x.reshape(val_x.shape[0], -1))
# Reshape the data back to its original shape
train_x = train_x.reshape(train_x.shape[0], train_x.shape[1], -1)
val_x = val_x.reshape(val_x.shape[0], val_x.shape[1], -1)
Com os dados preparados, podemos agora construir e treinar o modelo LSTM:
model.add(LSTM(units=128, input_shape=(train_x.shape[1:]), return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128, return_sequences=True))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(LSTM(units=128))
model.add(Dropout(0.2))
model.add(BatchNormalization())
model.add(Dense(units=32, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(units=2, activation='softmax'))
# Define the optimizer and compile the model
optimizer = tf.keras.optimizers.Adam(learning_rate=0.001)
model.compile(loss='sparse_categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
# Define early stopping
early_stopping = tf.keras.callbacks.EarlyStopping(patience=3)
# Train the model
history = model.fit(train_x, train_y, validation_data=(val_x, val_y), epochs=20, callbacks=[early_stopping])
Definimos o otimizador como Adam com uma taxa de aprendizado de 0,001 e compilamos o modelo usando entropia cruzada categórica esparsa como função de perda e precisão como métrica.
A parada antecipada é definida usando o retorno de chamada EarlyStopping para monitorar a perda de validação e interromper o treinamento se não melhorar após 3 épocas.
O modelo é treinado usando a função fit, passando os dados de treinamento (train_x e train_y), dados de validação (val_x e val_y) e os callbacks definidos. O treinamento é realizado por 20 épocas.
Você pode ajustar a arquitetura do modelo, hiperparâmetros e configuração de treinamento com base em seus requisitos específicos.
test_x = scaler.transform(test_x.reshape(test_x.shape[0], -1))
test_x = test_x.reshape(test_x.shape[0], test_x.shape[1], -1)
loss, accuracy = model.evaluate(test_x, test_y)
print(f'Test Loss: {loss:.4f}')
print(f'Test Accuracy: {accuracy*100:.2f}%')
Em seguida, usamos o método de avaliação do modelo para calcular a perda e a precisão dos dados de teste. O método de avaliação leva os dados de entrada de teste (test_x) e os rótulos de verdade de campo correspondentes (test_y). A perda calculada e a precisão são impressas no console.
Lembre-se de importar os módulos necessários no início do seu script:
import tensorflow as tf
from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dropout, BatchNormalization, Dense
Esse código permitirá que você treine um modelo LSTM para sua tarefa de classificação de compra/venda, normalize os dados e avalie o desempenho do modelo no conjunto de teste. Sinta-se à vontade para fazer quaisquer ajustes ou modificações de acordo com suas necessidades específicas.