Из этого руководства вы узнаете:
- Что такое машинное обучение?
- Почему веб-парсинг полезен для машинного обучения
- Как выполнять парсинг для машинного обучения
- Как использовать машинное обучение на данных, полученных с помощью парсинга
- Подробная информация о процессе обучения моделей машинного обучения с использованием данных, полученных с помощью парсинга
- Как настроить ETL при обработке данных для машинного обучения
Давайте рассмотрим эти вопросы подробнее!
Что такое машинное обучение?
Машинное обучение, также известное как ML, — это подраздел искусственного интеллекта (ИИ), посвященный созданию систем, способных учиться на основе данных. В частности, великая революция в применении машинного обучения к программному обеспечению и вычислительным системам заключается в том, что компьютеры не нужно явно программировать для решения проблемы машинного обучения. Это стало возможным благодаря системам машинного обучения, обучающимся на основе данных.
Как машины могут учиться на данных? Что ж, машинное обучение можно рассматривать как не что иное, как прикладную математику. Фактически, модели машинного обучения могут определять закономерности исходных данных, с которыми они сталкиваются, что позволяет им прогнозировать выходные данные при взаимодействии с новыми входными данными.
Почему веб-парсинг полезен для машинного обучения
Системам машинного обучения, да и вообще любой системе искусственного интеллекта,нужны данные, чтобы обучать модели, и именно здесь веб-парсинг открывает возможность специалистам по обработке данных.
Итак, вот несколько причин, по которым веб-парсинг важен для машинного обучения:
- Масштабный сбор данных: для эффективного обучения моделям машинного обучения, особенно моделям глубокого обучения, требуются огромные объемы данных. Веб-парсинг позволяет собирать крупномасштабные наборы данных, которые могут быть недоступны в других местах.
- Разнообразные и богатые источники данных: если у вас уже есть данные для обучения моделей машинного обучения, поиск в Интернете — это возможность расширить ваши наборы данных, поскольку в Интернете содержится огромное количество данных.
- Актуальная информация: иногда имеющиеся у вас данные не обновляются в соответствии с последними тенденциями, и именно здесь вам поможет веб-парсинг. Фактически, для моделей, основанных на самой последней информации (например, прогноз цен на акции, анализ настроений в новостяхи т. д.), поиск в Интернете может обеспечить получение актуальных данных.
- Повышение производительности модели: имеющихся у вас данных может просто не хватить — в зависимости от моделей или проекта, над которым вы работаете. По этой причине извлечение данных из Интернета с помощью веб-парсинга — это способ получить больше данных с целью повышения производительности модели и ее проверки.
- Анализ рынка: анализ отзывов, комментариев и оценок помогает понять настроения потребителей, что очень важно для бизнеса. Он также может помочь в сборе данных по новым темам и прогнозировании рыночных тенденций или общественного мнения.
Предварительные условия
В этом уроке вы узнаете, как выполнять веб-парсинг для машинного обучения на Python.
Чтобы воспроизвести приведенный ниже проект Python, ваша система должна соответствовать следующим требованиям:
- Python 3.6 или выше: подойдет любая версия Python выше 3.6. В частности, мы установим зависимости через
pip, который уже установлен в любой версии Python выше 3.4. - Jupyter Notebook 6.x: мы будем использовать Jupiter Notebook для анализа данных и составления прогнозов с помощью машинного обучения. Подойдет любая версия выше 6.x.
- IDE: VS CODE или любая другая среда разработки Python по вашему выбору.
Как выполнять парсинг для машинного обучения
В этом пошаговом разделе вы узнаете, как создать проект по веб-парсингу, который извлекает данные для дальнейшего анализа с помощью машинного обучения.
В деталях вы узнаете, как проанализировать Yahoo Finance, чтобы узнать цены акций NVIDIA. Затем мы будем использовать эти данные для машинного обучения.
Шаг №1: настройка среды
Прежде всего создайте репозиторий, называемый, например, scraping_project, в котором есть подпапки под названием data, notebooksи scripts следующим образом:
scraping_project/
├── data/
│ └── ...
├── notebooks/
│ └── analysis.ipynb
├── scripts/
│ └── data_retrieval.py
└── venv/
Где:
data_retrieval.pyбудет содержать вашу логику парсинга.analysis.ipynbбудет содержать логику машинного обучения.data/будут содержать очищенные данные для анализа с помощью машинного обучения.
Папка venv/ содержит виртуальную среду. Вы можете создать его следующим образом:
python3 -m venv venv
Чтобы активировать его, в Windows запустите:
venv\Scripts\activate
В macOS/Linux выполните:
source venv/bin/activate
Теперь вы можете установить все необходимые библиотеки:
pip install selenium requests pandas matplotlib scikit-learn tensorflow notebook
Шаг №2: определение целевой страницы
Чтобы получить исторические данные NVIDIA, перейдите по следующему URL-адресу:
https://finance.yahoo.com/quote/NVDA/history/
Однако на странице есть несколько фильтров, позволяющих определить, как вы хотите отображать данные:
Чтобы получить достаточно данных для машинного обучения, вы можете отфильтровать их на 5 лет. Для вашего удобства вы можете использовать следующий URL-адрес, который уже отфильтровывает данные по 5 годам:
https://finance.yahoo.com/quote/NVDA/history/?frequency=1d&period1=1574082848&period2=1731931014
На этой странице вы должны выбрать следующую таблицу и извлечь из нее данные:
Селектор CSS, определяющий таблицу, называется .table , поэтому в файле 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")
Пока что этот код выполняет следующее:
- Настраивает экземпляр драйвера Selenium Chrome
- Определяет целевой URL-адрес и дает команду Selenium посетить его
- Ожидает загрузки таблицы: в этом случае целевая таблица загружается с помощью Javascript, поэтому веб-драйвер ждет 20 секунд, чтобы убедиться, что таблица загружена
- Перехватывает всю таблицу с помощью специального селектора CSS
Шаг №3: извлеките данные и сохраните их в CSV-файле
На этом этапе вы можете сделать следующее:
- Извлеките заголовки из таблицы (они будут добавлены в CSV-файл в том виде, в каком они есть)
- Извлеките все данные из таблицы
- Преобразуйте данные в фрейм данных Numpy
Это можно сделать с помощью следующего кода:
# 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)
Шаг №4: сохраните CSV-файл в папке data/
Если вы посмотрите на созданную структуру папок, вы должны помнить, что файл data_retrieval.py находится в папке scripts/ . Вместо этого файл CVS необходимо сохранить в папке data/ , поэтому вы должны учитывать следующее в своем коде:
# 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()
Этот код определяет (абсолютный) текущий путь с помощью метода os.path.dirname(), переходит в папку data/ с помощью метода os.path.join(), обеспечивает его существование с помощью метода os.makedirs(data_dir, exist_ok=True), сохраняет данные в формате CSV файл с методом df.to_csv() из библиотеки Pandas и, наконец, завершает работу с драйвером.
Шаг №5: собираем все вместе
Вот полный код файла 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()
Итак, с помощью нескольких строк кода вы получили исторические данные об акциях NVIDIA за 5 лет и сохранили их в CSV-файле.
В Windows запустите приведенный выше скрипт с помощью:
python data_retrieval.py
Или, что эквивалентно, в Linux/macOS:
python3 data_retrieval.py
Ниже показано, как выглядят выходные данные после парсинга:
Использование машинного обучения на данных, полученных с помощью парсинга
Теперь, когда данные сохранены в CSV-файле, вы можете использовать машинное обучение для прогнозирования.
Давайте посмотрим, как это сделать, выполнив следующие шаги.
Шаг №1: создайте новый файл Jupyter Notebook
Чтобы создать новый файл Jupyter Notebook, перейдите в папку notebooks/ из основной папки:
cd notebooks
Затем откройте Jupyter Notebook следующим образом:
jupyter notebook
Когда браузер открыт, нажмите Создать > Python3 (ipykernel) , чтобы создать новый файл Jupyter Notebook:
Переименуйте файл, например, как analysis.ipynb.
Шаг №2: Откройте CSV-файл и покажите заголовок
Теперь вы можете открыть CSV-файл с данными и показать заголовок фрейма данных:
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()
Этот код отправляется в папку data/ с csv_path = "../data/nvda_stock_data.csv". Затем он открывает CSV-файл методом pd.read_csv() в качестве фрейма данных и показывает его заголовок (первые 5 строк) с помощью метода df.head().
Вот ожидаемый результат:
Шаг №3: визуализируйте временную тенденцию значения** Adj Close
Теперь, когда фрейм данных загружен правильно, вы можете визуализировать тренд значения Adj Close, которое представляет собой скорректированное значение закрытия:
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()
Этот фрагмент кода делает следующее:
df["Date"]обращается к столбцуDateфрейма данных и с помощью методаpd.to_datetime(), что гарантирует указание дат в заданном формате- Функция
df.sort_values()сортирует даты в столбцеDate. Это гарантирует, что данные будут отображаться в хронологическом порядке. plt.figure()задает размеры графика, аplt.plot()отображает его- Строки кода под комментарием
# Customize the plotполезны для настройки графика, в том числе указания заголовка, меток осей и расшифровки условных обозначений - Метод
plt.show()фактически позволяет отображать график
Ожидаемый результат выглядит примерно так:
На этом графике показана фактическая динамика скорректированных значений закрытых торгов с течением времени стоимости акций NVIDIA. Модель машинного обучения, которую вы будете обучать, должна будет как можно лучше их прогнозировать.
Шаг №3: подготовка данных для машинного обучения
Пора подготовить данные для машинного обучения!
Во-первых, вы можете выполнить очистку и подготовку данных:
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"]])
Этот код выполняет следующее:
- Преобразует значения
VolumeиOpenс помощью методаto _numeric() - Обрабатывает недостающие значения с помощью интерполяции для заполнения их методом
interpolate() - Масштабирует данные с помощью
MinMaxScaler() - Выбирает и преобразует (масштабирует) целевую переменную
Adj Closeс помощью методаfit_transform()
Шаг №4: создание обучающих и тестовых наборов
В этом уроке используется модель LSTM (долговременная кратковременная память), представляющая собой RNN (рекуррентную нейронную сеть), поэтому создайте последовательность шагов, позволяющих ей изучать данные:
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:]
Вот необходимый код:
- Создает последовательность из 60 временных шагов.
X— массив функций,y— массив целевого значения - Разделяет исходный фрейм данных следующим образом: 80% становится обучающим набором, 20% — тестовым набором
Шаг №5: обучение модели
Теперь вы можете тренировать RNN на обучающем наборе:
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)
Этот код выполняет следующее:
- Расширяет массив функций, которые должны быть готовы к использованию нейронной сети LSTM, используя метод
reshape()как для обучающих, так и для тестовых наборов - Создает нейронную сеть LSTM, задавая ее параметры
- Приспосабливает LSTM к обучающему набору, используя метод
fit()
Итак, модель уже подогнана к обучающему набору и готова к прогнозированию.
Шаг №6: Сделайте прогнозы и оцените производительность модели
Теперь модель готова прогнозировать значения Adj Close, и вы можете оценить ее производительность следующим образом:
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}")
Этот код выполняет следующее:
- Инвертирует значения на горизонтальной оси, чтобы последние данные можно было представить в хронологическом порядке. Это делается с помощью метода
inverse_transform(). - Оценивает модель, используя среднеквадратичную ошибку и рейтинга R^2.
Учитывая статистические ошибки, которые могут возникнуть из-за стохастической природы моделей машинного обучения, ожидаемый результат выглядит примерно так:
Это довольно хорошие значения, указывающие на то, что выбранная модель позволяет прогнозировать Adj Close, учитывая ее особенности.
Шаг №7: сравните фактические и прогнозируемые значения с графиком
В области машинного обучения аналитического сравнения результатов, которое мы выполняли на предыдущем этапе, иногда бывает недостаточно. Чтобы повысить вероятность того, что выбранная модель окажется удачной, типичным решением является также создание графика.
Например, обычным решением является создание графика, на котором фактические значения Adj Close сравниваются с прогнозируемыми моделью 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()
Вот необходимый код:
- Задает сравнение фактических и прогнозируемых значений на уровне тестового набора, поэтому фактические значения необходимо обрезать до формы тестового набора. Для этого используются методы
iloc()иflatten(). - Создает график, добавляет метки к осям и заголовку, а также управляет другими настройками для улучшения визуализации.
Ожидаемый результат выглядит примерно так:
Как показано на графике, значения, предсказанные нейронной сетью LSTM (желтая пунктирная линия), довольно хорошо предсказывают фактические значения (непрерывная синяя линия). Это было достойно уважения, так как аналитические результаты были хорошими, но сюжет, несомненно, помогает понять, что результат действительно хороший.
Шаг №8: собираем все вместе
Вот полный код 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()
Обратите внимание, что весь код является целенаправленным: при открытии пропущены части, показывающие заголовок фрейма данных, и отображаются только фактические значения Adj Close.
Эти шаги описаны в начале этого абзаца в рамках предварительного анализа данных. Они полезны для понимания того, что вы делаете с данными, прежде чем приступить к обучению модели машинного обучения.
ПРИМЕЧАНИЕ: код представлен по частям, но, учитывая стохастическую природу машинного обучения, рекомендуется запустить весь код целиком, чтобы правильно обучить и проверить модель LSTM. В противном случае полученный окончательный график может значительно отличаться.
Заметки о процессе обучения моделей машинного обучения на основе данных, полученных в ходе парсинга
Для простоты приведенное в этой статье пошаговое руководство непосредственно посвящено настройке нейронной сети LSTM.
На самом деле это не то, что происходит с моделями машинного обучения. Итак, когда вы пытаетесь решить проблему, для которой требуется модель машинного обучения, процесс выглядит следующим образом:
- Предварительный анализ данных: это самая важная часть процесса, потому что именно здесь вы изучаете имеющиеся данные, очищаете данные, удаляя значения NaN, управляете возможными дубликатами и решаете другие математические задачи, связанные с имеющимися данными.
- Обучение моделей машинного обучения: никогда не знаешь, будет ли первая задуманная модель лучшей для решения проблемы, с которой вы сталкиваетесь при использовании машинного обучения. Типичным решением является так называемая выборочная проверка, которая означает:
- Выполните обучение 3–4 моделей машинного обучения на обучающем наборе и затем оцените их эффективность.
- Получение 2–3 моделей машинного обучения, которые лучше всего работают на обучающем наборе, и настройка их гиперпараметров.
- сравнение производительности лучших моделей с настроенными гиперпараметрами на тестовом наборе;
- выбор той, которая лучше всего работает на тестовом наборе.
- Развертывание: наиболее эффективная модель внедряется в производственную среду.
Настройка ETL при обработке данных для машинного обучения
В начале этой статьи мы определили, почему веб-парсинг полезен для машинного обучения. Однако вы, возможно, заметили несогласованность в разработанном проекте, которая заключается в том, что данные, полученные с помощью веб-парсинга, были сохранены в CSV-файле.
Это обычная практика в машинном обучении, но следует учитывать, что лучше делать это в начале проекта машинного обучения, когда целью является поиск наилучшей модели, способной прогнозировать будущие значения целевых значений.
Когда лучшая модель будет найдена, последующая практика заключается в настройке конвейера ETL (Extract Transform Load) для извлечения новых данных из Интернета, их очистки и загрузки в базу данных.
Процесс может быть примерно таким:
- Извлечение: на этом этапе данные извлекаются из различных источников, включая Интернет, с помощью парсинга.
- Трансформация : собранные данные проходят процесс очистки и подготовки данных.
- Загрузка: извлеченные и преобразованные данные обрабатываются и сохраняются в базе данных или хранилище данных.
После сохранения данных на следующем этапе происходит интеграция с рабочими процессами машинного обучения, которые, среди прочего, переобучают модель на новых данных и повторно проверяют ее.
Заключение
В этой статье мы показали, как извлекать данные из Интернета с помощью парсинга и как использовать их для целей машинного обучения. Мы также рассказали о важности парсинга веб-страниц для машинного обучения и обсудили процесс обучения и структурирования ETL.
Хотя предлагаемый проект и прост, понятно, что лежащие в его основе процессы, особенно связанные со структурированием ETL для непрерывного извлечения данных из Интернета для улучшения модели машинного обучения, сопряжены со сложностями, требующими дальнейшего анализа.
Парсинг Yahoo Finance в реальных сценариях может оказаться гораздо сложнее, чем показано здесь. На сайте используются некоторые технологии защиты от парсинга, требующие особого внимания. Чтобы найти профессиональное полнофункциональное универсальное решение, ознакомьтесь с Парсером Yahoo Finance от Bright Data!
Если парсинг — не ваша сильная сторона, но вам все еще нужны данные для проектов машинного обучения, изучите наши решения для эффективного поиска данных, адаптированные к потребностям искусственного интеллекта и машинного обучения.
Создайте бесплатный аккаунт Bright Data сегодня, чтобы попробовать наши API парсеров или изучить наши наборы данных.
Кредитная карта не требуется
