Como usar o Web Scraping para aprendizado de máquina

Neste guia, você vai aprender:

• O que é aprendizado de máquina?
• Por que o web scraping é útil para aprendizado de máquina
• Como realizar a raspagem para aprendizado de máquina
• Como usar o aprendizado de máquina em dados extraídos
• Detalhes sobre o processo de treinamento de modelos de ML com dados extraídos
• Como configurar eTLs ao extrair dados para aprendizado de máquina

Vamos lá!

O que é aprendizado de máquina?

O aprendizado de máquina, também conhecido como ML, é uma subseção da Inteligência Artificial (IA) que se concentra na construção de sistemas capazes de aprender com dados. Em particular, a grande revolução resultante da aplicação do aprendizado de máquina a software e sistemas computacionais é que os computadores não precisam ser programados explicitamente para resolver um problema de ML. Graças aos sistemas de aprendizado de máquina que aprendem a partir de dados.

Como as máquinas podem aprender com os dados? Bem, você pode pensar no aprendizado de máquina como nada mais do que matemática aplicada. Os modelos de ML, na verdade, podem identificar os padrões dos dados subjacentes aos quais estão expostos, permitindo que eles façam previsões sobre as saídas quando expostos a novos dados de entrada.

Por que a captura de dados na Web é útil para aprendizado de máquina

Sistemas de aprendizado de máquina — mas, mais em geral, qualquer sistema de IA —precisam de dados para treinar os modelos, e é aí que o web scraping entra como uma oportunidade para profissionais de dados.

Então, aqui estão alguns motivos pelos quais o web scraping é importante para o aprendizado de máquina:

• Coleta de dados em escala: Modelos de aprendizado de máquina — e especialmente modelos de aprendizado profundo — exigem grandes quantidades de dados para serem treinados de forma eficaz. O web scraping permite a coleta de conjuntos de dados em grande escala que podem não estar disponíveis em outros lugares.
• Fontes de dados diversificadas e ricas: Se você já tem dados para treinar seus modelos de ML, explorar a web é uma oportunidade de ampliar seus conjuntos de dados, pois a web hospeda uma grande variedade de dados.
• Informações atualizadas: Às vezes, os dados que você tem não são atualizados com as últimas tendências, e é aqui que o web scraping ajuda você. Na verdade, para modelos que dependem das informações mais recentes (por exemplo, previsão do preço das ações, notícias, análise de sentimentos, etc.), o web scraping pode fornecer feeds de dados atualizados.
• Aprimorando o desempenho do modelo: Os dados que você tem podem simplesmente nunca ser suficientes, dependendo dos modelos ou do projeto em que você está trabalhando. Por esse motivo, recuperar dados da web usando web scraping é uma forma de obter mais dados com o objetivo de aprimorar o desempenho do seu modelo e validá-lo.
• Análise de mercado: Extrair avaliações, comentários e classificações ajuda a entender o sentimento do consumidor, o que é valioso para as empresas. Também pode ajudar na coleta de dados sobre tópicos emergentes e na previsão de tendências do mercado ou da opinião pública.

Pré-requisitos

Neste tutorial, você aprenderá como realizar web scraping para aprendizado de máquina em Python.

Para reproduzir o projeto Python abaixo, seu sistema precisa atender aos seguintes pré-requisitos:

• Python 3.6 ou superior: Qualquer versão do Python superior à 3.6 serve. Em particular, instalaremos as dependências via pip , que já está instalada com qualquer versão do Python maior que 3.4.
• Jupyter Notebook 6.x: Usaremos um Jupiter Notebook para analisar os dados e fazer previsões com aprendizado de máquina. Qualquer versão superior à 6.x serve.
• Um IDE: VS CODE ou qualquer outro IDE Python de sua escolha servirá.

Como realizar a raspagem para aprendizado de máquina

Nesta seção passo a passo, você aprenderá como criar um projeto de web scraping que recupera dados para serem analisados posteriormente com o aprendizado de máquina.

Em detalhes, você verá como usar o Yahoo Finance para obter os preços das ações da NVIDIA. Em seguida, usaremos esses dados para aprendizado de máquina.

Passo 1: Configurando o ambiente

Primeiro, crie um repositório — chamado, por exemplo, scraping_project— que tenha subpastas chamadas data, notebookse scripts , assim:

scraping_project/
├── data/
│   └── ...
├── notebooks/
│   └── analysis.ipynb
├── scripts/
│   └── data_retrieval.py
└── venv/

Onde:

• data_retrieval.py conterá sua lógica de raspagem.
• analysis.ipynb conterá a lógica de aprendizado de máquina.
• data/ conterá os dados extraídos para análise por meio de aprendizado de máquina.

A pasta venv/ contém o ambiente virtual. Você pode criá-lo assim:

python3 -m venv venv 

Para ativá-lo, no Windows, execute:

venv\Scripts\activate

No macOS/Linux, execute:

source venv/bin/activate

Agora você pode instalar todas as bibliotecas necessárias:

pip install selenium requests pandas matplotlib scikit-learn tensorflow notebook

Etapa #2: Definir a página de destino

Para obter os dados históricos da NVIDIA, você precisa acessar o seguinte URL:

https://finance.yahoo.com/quote/NVDA/history/

No entanto, a página apresenta alguns filtros que permitem definir como você deseja que os dados sejam exibidos:

Para recuperar dados suficientes para o aprendizado de máquina, você pode filtrá-los por 5 anos. Para sua conveniência, você pode usar o seguinte URL que já filtra os dados por 5 anos:

https://finance.yahoo.com/quote/NVDA/history/?frequency=1d&period1=1574082848&period2=1731931014

Nesta página, você precisa segmentar a tabela a seguir e recuperar os dados dela:

O seletor CSS que define a tabela é .table , então você pode escrever o seguinte código no arquivo data_retrieval.py :

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.common import NoSuchElementException
import pandas as pd
import os

# Configure Selenium
driver = webdriver.Chrome(service=Service())

# Target URL
url = "https://finance.yahoo.com/quote/NVDA/history/?frequency=1d&period1=1574082848&period2=1731931014"
driver.get(url)

# Wait for the table to load
try:
    WebDriverWait(driver, 20).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, ".table"))
    )
except NoSuchElementException:
    print("The table was not found, verify the HTML structure.")
    driver.quit()
    exit()

# Locate the table and extract its rows
table = driver.find_element(By.CSS_SELECTOR, ".table")
rows = table.find_elements(By.TAG_NAME, "tr")

Até agora, esse código faz o seguinte:

• Configura uma instância do driver Selenium Chrome
• Define o URL de destino e instrui o Selenium a visitá-lo
• Espera que a tabela seja carregada: Nesse caso, a tabela de destino é carregada por Javascript, então o driver web espera 20 segundos, apenas para ter certeza de que a tabela está carregada
• Intercepta a tabela inteira usando o seletor CSS dedicado

Etapa #3: Recupere os dados e salve-os em um arquivo CSV

Neste momento, você pode fazer o seguinte:

1. Extraia os cabeçalhos da tabela (os cabeçalhos serão anexados como estão no arquivo CSV)
2. Recupere todos os dados da tabela
3. Converta os dados em um quadro de dados Numpy

Você pode fazer isso com o seguinte código:

# Extract headers from the first row of the table
headers = [header.text for header in rows[0].find_elements(By.TAG_NAME, "th")]

# Extract data from the subsequent rows
data = []
for row in rows[1:]:
    cols = [col.text for col in row.find_elements(By.TAG_NAME, "td")]
    if cols:
        data.append(cols)

# Convert data into a pandas DataFrame
df = pd.DataFrame(data, columns=headers)

Etapa #4: Salve o arquivo CSV na pasta data/ 

Se você observar a estrutura de pastas criada, lembre-se de que o arquivo data_retrieval.py está na pasta scripts/ . O arquivo CVS, em vez disso, deve ser salvo na pasta data/ , então você deve considerar isso em seu código:

# Determine the path to save the CSV file
current_dir = os.path.dirname(os.path.abspath(__file__))  

# Navigate to the "data/" directory
data_dir = os.path.join(current_dir, "../data") 

# Ensure the directory exists 
os.makedirs(data_dir, exist_ok=True)  

# Full path to the CSV file
csv_path = os.path.join(data_dir, "nvda_stock_data.csv")  

# Save the DataFrame to the CSV file
df.to_csv(csv_path, index=False)
print(f"Historical stock data saved to {csv_path}")

# Close the WebDriver
driver.quit()

Esse código determina o caminho atual (absoluto) usando o método os.path.dirname (), navega até a pasta data/ com o método os.path.join (), garante que ele exista com o método os.makedirs (data_dir, exist_ok=True), salva os dados em um Arquivo CSV com o método df.to_csv () da biblioteca Pandas e, finalmente, sai do driver.

Passo 5: Juntando tudo

Aqui está o código completo para o arquivo data_retrieval.py :

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.common import NoSuchElementException
import pandas as pd
import os

# Configure Selenium
driver = webdriver.Chrome(service=Service())

# Target URL
url = "https://finance.yahoo.com/quote/NVDA/history/?frequency=1d&period1=1574082848&period2=1731931014"
driver.get(url)

# Wait for the table to load
try:
    WebDriverWait(driver, 5).until(
        EC.presence_of_element_located((By.CSS_SELECTOR, "table.table.yf-j5d1ld.noDl"))
    )
except NoSuchElementException:
    print("The table was not found, verify the HTML structure.")
    driver.quit()
    exit()

# Locate the table and extract its rows
table = driver.find_element(By.CSS_SELECTOR, ".table")
rows = table.find_elements(By.TAG_NAME, "tr")

# Extract headers from the first row of the table
headers = [header.text for header in rows[0].find_elements(By.TAG_NAME, "th")]

# Extract data from the subsequent rows
data = []
for row in rows[1:]:
    cols = [col.text for col in row.find_elements(By.TAG_NAME, "td")]
    if cols:
        data.append(cols)

# Convert data into a pandas DataFrame
df = pd.DataFrame(data, columns=headers)

# Determine the path to save the CSV file
current_dir = os.path.dirname(os.path.abspath(__file__))  

# Navigate to the "data/" directory
data_dir = os.path.join(current_dir, "../data") 

# Ensure the directory exists 
os.makedirs(data_dir, exist_ok=True)

# Full path to the CSV file  
csv_path = os.path.join(data_dir, "nvda_stock_data.csv")

# Save the DataFrame to the CSV file
df.to_csv(csv_path, index=False)
print(f"Historical stock data saved to {csv_path}")

# Close the WebDriver
driver.quit()

Então, com algumas linhas de código, você recuperou 5 anos de dados históricos sobre as ações da NVIDIA e os salvou em um arquivo CSV.

No Windows, inicie o script acima com:

python data_retrieval.py

Ou de forma equivalente, no Linux/macOS:

python3 data_retrieval.py

Abaixo está como os dados extraídos de saída aparecem:

Usando aprendizado de máquina em dados extraídos

Agora que os dados foram salvos em um arquivo CSV, você pode usar o aprendizado de máquina para fazer previsões.

Vamos ver como você pode fazer isso nas etapas a seguir.

Etapa #1: Crie um novo arquivo do Jupyter Notebook

Para criar um novo arquivo do Jupyter Notebook, navegue até a pasta notebooks/ a partir da pasta principal:

cd notebooks 

Em seguida, abra um Jupyter Notebook da seguinte forma:

jupyter notebook

Quando o navegador estiver aberto, clique em Novo > Python3 (ipykernel) para criar um novo arquivo do Jupyter Notebook:

Renomeie o arquivo, por exemplo, como analysis.ipynb.

Etapa #2: Abra o arquivo CSV e mostre a cabeça

Agora você pode abrir o arquivo CSV contendo os dados e mostrar o cabeçalho do quadro de dados:

import pandas as pd

# Path to the CSV file
csv_path = "../data/nvda_stock_data.csv"

# Open the CVS file
df = pd.read_csv(csv_path)

# Show head
df.head()

Esse código vai para a pasta data/ com csv_path = “.. /data/nvda_stock_data.csv ". Em seguida, ele abre o CSV com o método pd.read_csv () como um quadro de dados e mostra sua cabeça (as primeiras 5 linhas) com o método df.head ().

Aqui está o resultado esperado:

Etapa #3: Visualize a tendência ao longo do tempo do** Adj Close value

Agora que o quadro de dados está carregado corretamente, você pode visualizar a tendência do valor Adj Close , que representa o valor de fechamento ajustado:

import matplotlib.pyplot as plt

# Ensure the "Date" column is in datetime forma
df["Date"] = pd.to_datetime(df["Date"])

# Sort the data by date (if not already sorted)
df = df.sort_values(by="Date")

# Plot the "Adj Close" values over time
plt.figure(figsize=(10, 6))
plt.plot(df["Date"], df["Adj Close"], label="Adj Close", linewidth=2)

# Customize the plot
plt.title("NVDA Stock Adjusted Close Prices Over Time", fontsize=16) # Sets title
plt.xlabel("Date", fontsize=12) # Sets x-axis label
plt.ylabel("Adjusted Close Price (USD)", fontsize=12) # Sets y-axis label
plt.grid(True, linestyle="--", alpha=0.6) # Defines styles of the line
plt.legend(fontsize=12) # Shows legend
plt.tight_layout()

# Show the plot
plt.show()

Esse trecho faz o seguinte:

• df ["Date"] acessa a coluna Date do quadro de dados e, com o método pd.to_datetime (), garante que as datas estejam no formato de data
• O df.sort_values () classifica as datas da coluna Date . Isso garante que os dados sejam exibidos em ordem cronológica.
• plt.figure () define as dimensões do gráfico e plt.plot () o exibe
• As linhas de código abaixo do comentário # Personalizar o gráfico são úteis para personalizar o gráfico, fornecendo o título, os rótulos dos eixos e exibindo a legenda
• O método plt.show () é aquele que realmente permite que o gráfico seja exibido

O resultado esperado é algo assim:

Este gráfico mostra a tendência real dos valores fechados ajustados ao longo do tempo dos valores das ações da NVIDIA. O modelo de aprendizado de máquina que você treinará terá que predizê-los da melhor maneira possível.

Etapa #3: Preparando dados para aprendizado de máquina

É hora de preparar os dados para o aprendizado de máquina!

Primeiro, você pode fazer a limpeza e a preparação dos dados:

from sklearn.preprocessing import MinMaxScaler

# Convert data types
df["Volume"] = pd.to_numeric(df["Volume"].str.replace(",", ""), errors="coerce")
df["Open"] = pd.to_numeric(df["Open"].str.replace(",", ""), errors="coerce")

# Handle missing values 
df = df.infer_objects().interpolate() 

# Select the target variable ("Adj Close") and scale the data
scaler = MinMaxScaler(feature_range=(0, 1))  # Scale data between 0 and 1
data = scaler.fit_transform(df[["Adj Close"]])

Esse código faz o seguinte:

• Converte os valores Volume e Open com o método em _numeric ()
• Manipula valores ausentes usando interpolação para preenchê-los com o método interpolate ()
• Dimensiona os dados com o minMaxScaler ()
• Seleciona e transforma (dimensiona) a variável alvo Adj Close com o método fit_transform ()

Etapa #4: Crie os conjuntos de trem e teste

O modelo usado para este tutorial é um LSTM (Memória de Longo Prazo), que é uma RNN (Rede Neural Recorrente), então crie uma sequência de etapas para permitir que ela aprenda os dados:

import numpy as np

# Create sequences of 60 time steps for prediction
sequence_length = 60
X, y = [], []

for i in range(sequence_length, len(data)):
    X.append(data[i - sequence_length:i, 0])  # Last 60 days
    y.append(data[i, 0])  # Target value

X, y = np.array(X), np.array(y)

# Split into training and test sets
split_index = int(len(X) * 0.8)  # 80% training, 20% testing
X_train, X_test = X[:split_index], X[split_index:]
y_train, y_test = y[:split_index], y[split_index:]

Este código:

• Cria uma sequência de 60 intervalos de tempo. X é a matriz das características, y é a matriz do valor alvo
• Divide o quadro de dados inicial da seguinte forma: 80% se torna o conjunto do trem, 20% o conjunto de teste

Etapa #5: Treine o modelo

Agora você pode treinar o RNN no conjunto de trens:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM

# Reshape X for LSTM [samples, time steps, features]
X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))

# Build the Sequential Neural Network
model = Sequential()
model.add(LSTM(32, activation="relu", return_sequences=False))
model.add(Dense(1))
model.compile(loss="mean_squared_error", optimizer="adam")

# Train the Model
history = model.fit(X_train, y_train, epochs=20, batch_size=32, validation_data=(X_test, y_test), verbose=1)

Esse código faz o seguinte:

• Recompõe a matriz de recursos para ficar pronta para a rede neural LSTM usando o método reshape (), tanto para o trem quanto para os conjuntos de teste
• Constrói a rede neural LSTM definindo seus parâmetros
• Ajusta o LSTM ao conjunto de trens usando o método fit ()

Então, o modelo agora se ajustou ao conjunto de trens e está pronto para fazer previsões.

Etapa #6: Faça previsões e avalie o desempenho do modelo

O modelo agora está pronto para prever os valores de Adj Close e você pode avaliar seu desempenho da seguinte forma:

from sklearn.metrics import mean_squared_error, r2_score

# Make Predictions
y_pred = model.predict(X_test)

# Inverse scale predictions and actual values for comparison
y_test = scaler.inverse_transform(y_test.reshape(-1, 1))
y_pred = scaler.inverse_transform(y_pred)

# Evaluate the Model
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

# print results
print("\nLSTM Neural Network Results:")
print(f"Mean Squared Error: {mse:.2f}")
print(f"R-squared Score: {r2:.2f}")

Esse código faz o seguinte:

• Inverte os valores no eixo horizontal para que os dados possam ser apresentados posteriormente em ordem cronológica. Isso é feito com o método inverse_transform ().
• Avalia o modelo usando o erro quadrático médio  e a pontuação R^2.

Considerando os erros estatísticos que podem ocorrer devido à natureza estocástica dos modelos de ML, o resultado esperado é mais ou menos assim:

Esses são valores muito bons, indicando que o modelo escolhido é bom para prever o Adj Closedadas suas características.

Etapa #7: Compare valores reais e valores previstos com um gráfico

Quando se trata de aprendizado de máquina, comparar os resultados analiticamente, como fizemos na etapa anterior, às vezes pode não ser suficiente. Para aumentar as chances de que o modelo escolhido seja bom, uma solução típica é também criar um gráfico.

Por exemplo, uma solução comum é criar um gráfico que compare os valores reais de Adj Close com os previstos pelo modelo LSTM:

# Visualize the Results
test_results = pd.DataFrame({
    "Date": df["Date"].iloc[len(df) - len(y_test):],  # Test set dates
    "Actual": y_test.flatten(),
    "Predicted": y_pred.flatten()
})

# Setting plot
plt.figure(figsize=(12, 6))
plt.plot(test_results["Date"], test_results["Actual"], label="Actual Adjusted Close", color="blue", linewidth=2)
plt.plot(test_results["Date"], test_results["Predicted"], label="Predicted Adjusted Close", color="orange", linestyle="--", linewidth=2)
plt.title("Actual vs Predicted Adjusted Close Prices (LSTM)", fontsize=16)
plt.xlabel("Date", fontsize=12)
plt.ylabel("Adjusted Close Price (USD)", fontsize=12)
plt.legend()
plt.grid(alpha=0.6)
plt.tight_layout()
plt.show()

Este código:

• Define a comparação entre os valores reais e previstos no nível do conjunto de teste, portanto, os valores reais devem ser ajustados para o formato que o conjunto de teste possui. Isso é feito com os métodos iloc () e flatten ().
• Cria o gráfico, adiciona rótulos aos eixos e ao título e gerencia outras configurações para melhorar a visualização.

O resultado esperado é mais ou menos assim:

Como mostra o gráfico, os valores previstos pela rede neural LSTM (linha pontilhada amarela) predizem muito bem os valores reais (linha azul contínua). Isso foi respeitável, pois os resultados analíticos foram bons, mas o gráfico certamente ajuda a visualizar que o resultado é realmente bom.

Passo 8: Juntando tudo

Aqui está o código completo para o notebook analysis.ipynb :

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
from sklearn.metrics import mean_squared_error, r2_score
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM

# Path to the CSV file
csv_path = "../data/nvda_stock_data.csv"  
# Open CSV as data frame
df = pd.read_csv(csv_path)

# Convert "Date" to datetime format
df["Date"] = pd.to_datetime(df["Date"])

# Sort by date
df = df.sort_values(by="Date")

# Convert data types
df["Volume"] = pd.to_numeric(df["Volume"].str.replace(",", ""), errors="coerce")
df["Open"] = pd.to_numeric(df["Open"].str.replace(",", ""), errors="coerce")

# Handle missing values 
df = df.infer_objects().interpolate()

# Select the target variable ("Adj Close") and scale the data
scaler = MinMaxScaler(feature_range=(0, 1))  # Scale data between 0 and 1
data = scaler.fit_transform(df[["Adj Close"]])

# Prepare the Data for LSTM
# Create sequences of 60 time steps for prediction
sequence_length = 60
X, y = [], []

for i in range(sequence_length, len(data)):
    X.append(data[i - sequence_length:i, 0])  # Last 60 days
    y.append(data[i, 0])  # Target value

X, y = np.array(X), np.array(y)

# Split into training and test sets
split_index = int(len(X) * 0.8)  # 80% training, 20% testing
X_train, X_test = X[:split_index], X[split_index:]
y_train, y_test = y[:split_index], y[split_index:]

# Reshape X for LSTM [samples, time steps, features]
X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
X_test = X_test.reshape((X_test.shape[0], X_test.shape[1], 1))

# Build the Sequential Neural Network
model = Sequential()
model.add(LSTM(32, activation="relu", return_sequences=False))
model.add(Dense(1))
model.compile(loss="mean_squared_error", optimizer="adam")

# Train the Model
history = model.fit(X_train, y_train, epochs=20, batch_size=32, validation_data=(X_test, y_test), verbose=1)

# Make Predictions
y_pred = model.predict(X_test)

# Inverse scale predictions and actual values for comparison
y_test = scaler.inverse_transform(y_test.reshape(-1, 1))
y_pred = scaler.inverse_transform(y_pred)

# Evaluate the Model
mse = mean_squared_error(y_test, y_pred)
r2 = r2_score(y_test, y_pred)

# Print results
print("\nLSTM Neural Network Results:")
print(f"Mean Squared Error: {mse:.2f}")
print(f"R-squared Score: {r2:.2f}")

# Visualize the Results
test_results = pd.DataFrame({
    "Date": df["Date"].iloc[len(df) - len(y_test):],  # Test set dates
    "Actual": y_test.flatten(),
    "Predicted": y_pred.flatten()
})

# Setting plot
plt.figure(figsize=(12, 6))
plt.plot(test_results["Date"], test_results["Actual"], label="Actual Adjusted Close", color="blue", linewidth=2)
plt.plot(test_results["Date"], test_results["Predicted"], label="Predicted Adjusted Close", color="orange", linestyle="--", linewidth=2)
plt.title("Actual vs Predicted Adjusted Close Prices (LSTM)", fontsize=16)
plt.xlabel("Date", fontsize=12)
plt.ylabel("Adjusted Close Price (USD)", fontsize=12)
plt.legend()
plt.grid(alpha=0.6)
plt.tight_layout()
plt.show()

Observe que todo esse código vai diretamente para a meta, ignorando as partes que mostram a cabeça do quadro de dados ao abri-lo e traçando apenas os valores reais de Adj Close .    

Essas etapas foram relatadas no início deste parágrafo como parte da análise preliminar de dados e são úteis para entender o que você está fazendo com os dados antes de realmente treinar um modelo de ML.

NOTA: O código foi apresentado peça por peça, mas, considerando a natureza estocástica do ML, a sugestão é executar todo o código para treinar e validar adequadamente o modelo LSTM. Caso contrário, o gráfico final resultante pode ser significativamente diferente.

Notas sobre o processo de treinamento de modelos de ML com dados extraídos

Por uma questão de simplicidade, o guia passo a passo fornecido neste artigo aborda diretamente o ajuste de uma rede neural LSTM.

Na realidade, isso não é o que acontece com os modelos de ML. Então, quando você tenta resolver um problema que precisa de um modelo de ML, o processo é o seguinte:

• Análise preliminar de dados: Essa é a parte mais importante do processo porque é onde você entende os dados que tem, faz a limpeza de dados removendo valores de NaN, gerencia eventuais duplicatas e resolve outros problemas matemáticos relacionados aos dados que você tem.
• Treinando modelos de ML: Você nunca sabe se o primeiro modelo que você tem em mente será o melhor para resolver o problema que você está enfrentando com o ML. Uma solução típica é realizar a chamada verificação pontual  , que significa:
  • Treinar modelos de 3-4 ML no conjunto de trens e avaliar como eles funcionam nele.
  • Obter os modelos de 2 a 3 ML com melhor desempenho no conjunto de trens e ajustar seus hiperparâmetros.
  • Comparando o desempenho dos melhores modelos com hiperparâmetros ajustados no conjunto de testes.
  • Escolher o que tem melhor desempenho no conjunto de testes.
• Implantação: O modelo com melhor desempenho é, então, aquele que será implantado na produção.

Configurando ETLs ao extrair dados para aprendizado de máquina

No início deste artigo, definimos por que o web scraping é útil para o aprendizado de máquina. No entanto, você deve ter notado uma incoerência no projeto desenvolvido que se baseia no fato de que os dados recuperados via web scraping foram salvos em um arquivo CSV.

Essa é uma prática comum no aprendizado de máquina, mas você deve considerar que é melhor fazer isso no início de um projeto de ML, quando o objetivo é encontrar o melhor modelo que possa prever valores futuros dos valores-alvo.

Quando o melhor modelo for encontrado, a prática subsequente é configurar um pipeline ETL (Extract Transform Load) para recuperar novos dados da web, limpá-los e carregá-los em um banco de dados.

O processo pode ser algo assim:

• Extrair: Essa fase recupera os dados de várias fontes, incluindo a web por meio de scaping
• Transformar: Os dados coletados passam pelo processo de limpeza e preparação de dados
• Carregar: Os dados recuperados e transformados são processados e salvos em um banco de dados ou armazém de dados

Depois que os dados são armazenados, a fase subsequente fornece a integração com os fluxos de trabalho de aprendizado de máquina que, entre outras coisas, treinam novamente o modelo em novos dados e o revalidam.

Conclusão

Neste artigo, mostramos como recuperar dados da web por meio de raspagem e como usá-los para fins de aprendizado de máquina. Também apresentamos a importância do web scraping para o aprendizado de máquina e discutimos o processo de treinamento e estruturação de ETLs.

Embora o projeto proposto seja simples, é compreensível que os processos subjacentes — especialmente aqueles relacionados à estruturação de ETLs para recuperar dados da web continuamente para melhorar o modelo de ML — introduzam complexidades que devem ser analisadas mais detalhadamente.

Analisar o Yahoo Finance em cenários do mundo real pode ser muito mais complexo do que o mostrado aqui. O site emprega algumas tecnologias anti-raspagem, exigindo atenção extra. Para uma solução profissional, completa e completa, confira o Yahoo Finance Scraperda Bright Data!

Se a extração não é seu forte, mas você ainda precisa de dados para projetos de aprendizado de máquina, explore nossas soluções para recuperação eficiente de dados adaptadas às necessidades de IA e aprendizado de máquina.

Crie uma conta gratuita da Bright Data hoje para experimentar nossas APIs de scraper ou explorar nossos conjuntos de dados.