Раскрытие возможностей оперативной инженерии для специалистов по обработке и анализу данных

Как и зачем писать эффективные подсказки, если вы работаете с данными

Благодаря моделям GPT быстрое проектирование становится областью интересов Data Science. Вначале мы видели множество любопытных людей по всему миру, которые тестировали ChatGPT, чтобы обмануть его. Затем, хотя эта тенденция (наконец-то!) завершилась, движение людей, использующих ее для автоматизации скучных вещей или для помощи в решении общих задач, неуклонно растет.

Разработчики и специалисты по данным получают большие преимущества от использования таких систем подсказок, как ChatGPT. Итак, в этой статье мы увидим обзор оперативной разработки и того, как писать эффективные подсказки для специалистов по данным.

Я знаю, что вы получаете большую пользу от ChatGPT, не так ли?! Но правда в том, что иногда мы не можем просто получить от этого то, что хотели бы, как специалисты по данным. Итак, давайте посмотрим, как мы можем улучшить свои навыки подсказок, применив некоторые простые меры предосторожности.

Вот что вы прочитаете в этой статье:

Table of Contents:

The importance of prompt engineering today
How prompt engineering can affect Data Scientists
Examples of effective prompts for Data Scientists

Важность оперативного инжиниринга сегодня

Словом последних 150 лет может быть «автоматизация». На самом деле, мир эволюционировал от ручного производства к сборочным конвейерам. И хотя ремесла по-прежнему (очень) ценны, «массовое производство» стало словом, связанным с «автоматизацией».

Механизация и автоматизация работы растут, и это проникает в различные области, не только те, которые непосредственно связаны с производством товаров, как, например, обрабатывающая промышленность или сельское хозяйство.

Если мы посмотрим, например, на программное обеспечение, первое, что мы должны увидеть, это автоматизация. Когда я изучал Python около трех лет назад, один наставник, просматривая мой первый проект, сказал мне: «Федерико, разработка программного обеспечения — это автоматизация вещей!». И, если вы спросите, то да: мой первый проект был бардаком (как и все, что мы делаем впервые!).

В любом случае, вот правда: люди развивались с четкой целью: автоматизировать вещи. Это может быть связано с автоматизацией скучных вещей или «тяжелой работы». Это не имеет значения; дело в направлении к автоматизации.

В этом сценарии быстрое проектирование — это всего лишь новейший инструмент, который может помочь нам автоматизировать работу. С точки зрения «кода» это означает автоматизацию того, что можно автоматизировать: разработка программного обеспечения — это автоматизация по своей сути, а использование быстрого проектирования означает еще более сильное продвижение автоматизации.

На самом деле правда в том, что даже в разработке программного обеспечения есть скучные задачи, даже если, например, мы создали классы, которые можно импортировать (но нужно немного модифицировать).

Задумайтесь об этом на мгновение: как Data Scientist, сколько прототипов в неделю вы разрабатываете? И сколько времени у вас есть на их разработку?

Вы создаете прототип и что дальше? Спецификации проектов меняются, заказчик меняет идеи, ваш начальник недоволен… ну, вы назвали это.

Итак, почему мы должны тратить много усилий на малоценные, но трудоемкие задачи, а не автоматизировать их? Вот, на мой взгляд, основные концепции оперативной инженерии.

Итак, давайте посмотрим, как проектирование подсказок может повлиять на специалистов по данным, а затем посмотрим, как мы можем создавать полезные и эффективные подсказки.

Как оперативное проектирование может повлиять на специалистов по данным

У каждой новой технологии есть свои плюсы и минусы, как и в быстром инжиниринге. Сначала рассмотрим плюсы, а потом минусы.

Быстрая разработка для специалистов по данным: плюсы

1. Быстрое обучение. Если вы новичок в науке о данных (и в разработке программного обеспечения в целом), вы найдете очень полезный инструмент, такой как ChatGPT, потому что это похоже на то, чтобы старший разработчик был доступен 24/7. В любом случае, ему не следует доверять как оракулу, в первую очередь потому, что он все еще допускает некоторые ошибки. Я написал специальную статью о том, как эффективно начать программировать в эпоху ChatGPT здесь, если вам интересно.
2. Быстрые прототипы. На мой взгляд, одна из самых важных частей работы Data Scientist — прототипирование. На самом деле, очень часто нам нужно дать быстрый ответ на основе данных (часто с небольшим количеством доступных данных. Очень часто с грязными данными). Таким образом, прототип — это то, что может дать смысл ответа, который нужен клиенту, давая нам время для: а) запроса/получения дополнительных данных, б) запроса/получения дополнительных спецификаций, в) очистки данных и г) создания необходимых исследовать.
3. Быстрая отладка и управление ошибками. Мы должны быть честными: отладка и управление ошибками в разработке программного обеспечения — это скорее проклятие, чем удовольствие. Это также верно, когда мы разрабатываем программное обеспечение для алгоритмов машинного/глубокого обучения. ChatGPT — отличный инструмент для отладки и управления ошибками: при правильной подсказке он может найти ошибки и ошибки за считанные секунды, что позволяет нам сэкономить много времени и усилий. Небольшое напоминание: поскольку ChatGPT (и подобные инструменты) работают в облаке, а также могут использовать наши подсказки для обучения своих алгоритмов, помните, что не следует писать код с важной информацией, потому что они могут доставить вам неприятности в случае утечки данных.
4. Ускоренное исследование. Важной частью работы Data Scientist является проведение исследований. Нам абсолютно необходимо исследовать множество материалов для решения наших проблем, таких как: информация о конкретных библиотеках и их использовании, информация, связанная со знанием предметной области проблемы, с которой мы сталкиваемся, и т. д. Ну, хорошая подсказка, как правило, полезна, чтобы позволить нам получить нужную нам информацию. Единственное, что нужно помнить, это то, что нам всегда нужно проверять правильность вывода, углубляясь в интернет или в книги. Особенно с кодом всегда важно читать документацию: в противном случае есть риск скопировать и вставить код, фактически не понимая его.

Быстрая разработка для специалистов по данным: минусы

1. Возможность потерять работу. Да, мы должны это сказать: инструменты ИИ могут заставить нас потерять работу. Это кажется противоречием: в эти месяцы потребность в специалистах по данным на рынке возрастает, но такие инструменты, как ChatGPT, могут нас заменить. Что ж, скажем правду: эта возможность пока далека, потому что инструменты ИИ нуждаются в наблюдении эксперта, как мы уже обсуждали в профи. Конечно, вы можете запросить некоторый код и некоторый анализ данных, но если вы не знаете, как его использовать, что вы будете делать с кодом? Так что да: оперативное проектирование может привести к потере работы для некоторых специалистов по данным, но это вопрос нескольких лет, а не месяцев.
2. Возможность забыть, как программировать. Это актуальная проблема. Если мы слишком полагаемся на быстрое проектирование, а не на самостоятельное написание кода, мы можем забыть, как кодировать. Вы знаете: программирование — это вопрос практики, и это требует каждодневной практики. Конечно, это как ездить на велосипеде: вы никогда не забудете, как это делать. Но вы знаете: слишком много полагаясь на подсказки, а не на написание кода, вы можете атрофировать мышцы, потому что вам стало слишком комфортно. Итак, используйте такие инструменты, как ChatGPT, но не полагайтесь только на них: старайтесь писать как можно больше кода. Потому что я знаю, что ты любишь программировать, так что не оставляй это слишком много машинам.
3. Возможность не узнавать новое. Прелесть работы в сфере ИТ, особенно в области данных, заключается в том, что новые темы и технологии рождаются едва ли каждый день. Это одна из самых важных причин, почему я сменила профессию на работу в ИТ: потому что я люблю всегда узнавать новое, и мне бы хотелось, чтобы это признавали хорошим делом (да, есть направления/компании где самосовершенствование не считается хорошим делом). Но если вы полагаетесь только на ответ, полученный из ваших подсказок, и копируете и вставляете код (или полученную информацию), вы не узнаете ничего нового. На прицеле кода как минимум нужно спросить пояснений, потом читать документацию. А затем, если возможно, попробуйте код в разных сценариях, чтобы вы могли освоиться с полученным кодом. Это тот же подход, который нам нужен, когда мы запрашиваем общую информацию: всегда углубляйте их, читая другие источники (как всегда и должно быть: но давайте просто помнить об этом!).
4. Возможность реализации «многословного кода». Тот факт, что фрагмент кода просто работает, не является веской причиной оставлять его как есть, как вы знаете. Качество кода также важно для тех, кто будет читать этот фрагмент в будущем (возможно, для вас). Иногда из-за различных факторов (часто из-за неправильных подсказок) такие инструменты, как ChatGPT, могут выдать нам «многословный код» с ненужными частями. И здесь возникает важность профессионала: не копируйте и не вставляйте слепо. Если вы скопируете и вставите его, после того как убедитесь, что он работает, постарайтесь улучшить его, насколько это возможно.

Примеры эффективных подсказок для специалистов по данным

Теперь, помня об этих плюсах и минусах, давайте посмотрим на некоторые эффективные подсказки, которые мы можем создать в ChatGPT, чтобы улучшить и ускорить нашу работу в качестве специалистов по данным.

Пример №1: прототип

Предположим, мы изучаем пример бинарной классификации. Мы хотим сравнить три модели машинного обучения, используя кривые обучения, но на самом деле мы не помним код, который нужно использовать. Кроме того, наши репозитории немного запутаны, и мы не хотим тратить много времени.

Чтобы ускорить нашу работу в таких ситуациях, мы можем запросить у ChatGPT подсказку, подобную следующей: «Создайте на Python задачу бинарной классификации с синтетическими данными. Стандартизируйте данные с помощью стандартного скейлера, затем разделите данные на поезд и тестовый набор. Затем подберите набор поездов со случайным лесом, классификаторами KNN и SVM. Затем постройте кривую ROC для сравнения моделей». И вот результаты:

Конечно! Я могу помочь вам создать задачу бинарной классификации с использованием синтетических данных в Python и применить стандартный масштабатор для стандартизации данных. Затем мы можем разделить данные на обучающие и тестовые наборы. Наконец, мы подберем набор поездов с тремя классификаторами: случайный лес, K-ближайшие соседи (KNN) и метод опорных векторов (SVM), а также построим кривую ROC для сравнения моделей.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.metrics import roc_curve, auc

# Generate synthetic data for binary classification
X, y = make_classification(n_samples=1000, n_features=20, n_informative=10,
        n_redundant=10, random_state=42)

# Standardize the data using StandardScaler
scaler = StandardScaler()
X = scaler.fit_transform(X)

# Split the data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2,
                                    random_state=42)

# Fit the train set with classifiers
rf_classifier = RandomForestClassifier(random_state=42)
knn_classifier = KNeighborsClassifier()
svm_classifier = SVC(probability=True, random_state=42)

rf_classifier.fit(X_train, y_train)
knn_classifier.fit(X_train, y_train)
svm_classifier.fit(X_train, y_train)

# Generate predictions for the test set
rf_probs = rf_classifier.predict_proba(X_test)[:, 1]
knn_probs = knn_classifier.predict_proba(X_test)[:, 1]
svm_probs = svm_classifier.predict_proba(X_test)[:, 1]

# Calculate false positive rate, true positive rate,
# and area under the curve for ROC curve
rf_fpr, rf_tpr, _ = roc_curve(y_test, rf_probs)
rf_auc = auc(rf_fpr, rf_tpr)

knn_fpr, knn_tpr, _ = roc_curve(y_test, knn_probs)
knn_auc = auc(knn_fpr, knn_tpr)

svm_fpr, svm_tpr, _ = roc_curve(y_test, svm_probs)
svm_auc = auc(svm_fpr, svm_tpr)

# Plot the ROC curve
plt.figure()
plt.plot(rf_fpr, rf_tpr, label=f'Random Forest (AUC = {rf_auc:.2f})')
plt.plot(knn_fpr, knn_tpr, label=f'KNN (AUC = {knn_auc:.2f})')
plt.plot(svm_fpr, svm_tpr, label=f'SVM (AUC = {svm_auc:.2f})')
plt.plot([0, 1], [0, 1], 'k--')
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic')
plt.legend(loc='lower right')
plt.show()

Предоставленный код создает задачу синтетической двоичной классификации с использованием функции make_classification scikit-learn. Затем он применяет StandardScaler для стандартизации данных и разбивает их на набор поездов и тестовый набор.

Затем на наборе поездов обучаются три классификатора: случайный лес, K-ближайшие соседи (KNN) и машина опорных векторов (SVM). Для оценки классификаторы генерируют вероятности для набора тестов, используя метод predict_proba.

Следующий шаг включает в себя построение кривой рабочих характеристик приемника (ROC) для сравнения производительности классификаторов. Частота ложноположительных результатов (FPR) и частота истинных положительных результатов (TPR) рассчитываются с помощью функции roc_curve, а площадь под кривой (AUC) рассчитывается с помощью функции auc.

Наконец, кривая ROC строится с использованием matplotlib, при этом AUC каждого классификатора отображается в легенде. Кривая представляет собой компромисс между истинно положительными показателями и ложноположительными показателями для каждого классификатора, что позволяет визуально сравнивать их производительность.

Изучая кривую ROC и сравнивая значения AUC, вы можете оценить относительную производительность классификаторов Random Forest, KNN и SVM для данной задачи бинарной классификации.

Теперь, если мы скопируем и вставим этот код в блокнот Jupyter, мы получим:

Мы получили то, что хотели, поэтому давайте разберем подсказку:

1. Это конкретно. Я указал: а) язык (Python), б) тип проблемы (бинарная классификация), в) процесс, которому необходимо следовать (создание данных, нормализация данных, разделение данных) и г) используемые модели машинного обучения.
2. В нем есть все необходимое. Нет лишних слов, которые могут создать путаницу. Подсказка переходит прямо к делу.
3. Он короткий. Это всего 3 строчки. Более длинные подсказки могут привести к неправильным выводам или привести к тому, что модель добавит информацию, которая может нам не понадобиться. Если вам нужно вставить «длинные подсказки», я советую разделить «большую задачу» на более мелкие задачи и вводить разные короткие подсказки, которые могут быть последовательными. Чтобы было понятно, вышеприведенное приглашение можно разделить на последовательные чаты, например: а) «создать набор данных бинарной классификации с помощью Python, нормализовать данные и разделить их на поезд и тестовый набор», б) «подогнать тест поезда с классификаторами случайного леса, SVM и KNN. Затем распечатайте кривую ROC».

Пример №2: исследование

Предположим, мы знаем, что полиномиальная регрессия обычно дает переобучение, но нам нужно доказательство, потому что мы никогда этого не видели. Подсказка может быть примерно такой: «Я знаю, что модели полиномиальной регрессии обычно перекрываются: не могли бы вы показать мне кое-что, создав данные на Python?»

И вот что мы получаем:

Конечно! Я могу сгенерировать некоторые случайные данные и продемонстрировать, как полиномиальная регрессия может привести к переоснащению. Вот пример на Python:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures

# Generate random data
np.random.seed(0)
X = np.linspace(-3, 3, 100)
y = 0.5 * X**2 + X + np.random.normal(0, 1, 100)

# Reshape the input data
X = X.reshape(-1, 1)

# Plot the original data
plt.scatter(X, y, color='b', label='Data')

# Fit polynomial regression models of different degrees
degrees = [1, 4, 15]
colors = ['r', 'g', 'm']
for degree, color in zip(degrees, colors):
    # Create polynomial features
    polynomial_features = PolynomialFeatures(degree=degree)
    X_poly = polynomial_features.fit_transform(X)

    # Fit the polynomial regression model
    model = LinearRegression()
    model.fit(X_poly, y)

    # Predict the values
    y_pred = model.predict(X_poly)

    # Plot the fitted curve
    plt.plot(X, y_pred, color=color, linewidth=2, label=f'Degree {degree}')

# Add labels and title to the plot
plt.xlabel('X')
plt.ylabel('y')
plt.title('Polynomial Regression - Overfitting Example')
plt.legend(loc='upper left')

# Display the plot
plt.show()

Этот код генерирует случайные точки данных с квадратичной зависимостью и добавляет некоторый шум к значениям y. Затем он подбирает модели полиномиальной регрессии различных степеней (1, 4 и 15 в этом примере) к данным и строит полученные кривые.

Вы заметите, что по мере увеличения степени полинома модель начинает соответствовать шуму в данных, а не основному тренду. Это пример переоснащения. Линейная модель (степень 1) слишком проста, чтобы отразить основную квадратичную зависимость, в то время как полином высокой степени (степень 15) пытается точно соответствовать каждой точке данных, что приводит к сильно колеблющейся кривой.

Важно отметить, что приведенный мной пример является простой иллюстрацией переобучения в полиномиальной регрессии. На практике вы обычно используете более реалистичные и сложные наборы данных для оценки и решения проблем переобучения.

Теперь давайте посмотрим, что мы получаем в Jupyter Notebook:

Итак, этот график показывает, что при некоторых квадратично распределенных данных:

• Линейная модель не может захватить путь.
• Полиномы 4-й и 15-й степени «слишком хорошо захватывают путь».

Теперь скажите мне: означает ли это, что два многочлена совпадают?

Остановите чтение на секунду, чтобы подумать об этом.

Ну и да и нет, но прежде всего нет. На самом деле, как мы знаем, переоснащение происходит, когда:

1. Мы определяем метрики для оценки наших данных.
2. Метрики рассчитываются как на обучающем, так и на тестовом наборах, и мы обнаруживаем большие численные различия между ними.

Таким образом, эта подсказка не удовлетворяет, и мы должны просить больше. Например, мы могли бы спросить: «Хорошо, используйте те же данные и те же полиномы. Затем нормализуйте данные, разделите набор данных на обучающий и тестовый наборы и рассчитайте R² для обоих наборов».

И мы получаем:

Конечно! Вот обновленная версия кода, который нормализует данные, разбивает их на обучающие и тестовые наборы и вычисляет оценку R² для обоих наборов:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score

# Generate random data
np.random.seed(0)
X = np.linspace(-3, 3, 100)
y = 0.5 * X**2 + X + np.random.normal(0, 1, 100)

# Reshape the input data
X = X.reshape(-1, 1)

# Normalize the data
X_normalized = (X - np.mean(X)) / np.std(X)
y_normalized = (y - np.mean(y)) / np.std(y)

# Split the data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(
    X_normalized, y_normalized, test_size=0.2, random_state=0
)

# Plot the original data
plt.scatter(X_normalized, y_normalized, color='b', label='Data')

# Fit polynomial regression models of different degrees
degrees = [1, 4, 15]
colors = ['r', 'g', 'm']
for degree, color in zip(degrees, colors):
    # Create polynomial features
    polynomial_features = PolynomialFeatures(degree=degree)
    X_poly_train = polynomial_features.fit_transform(X_train)
    X_poly_test = polynomial_features.transform(X_test)

    # Fit the polynomial regression model
    model = LinearRegression()
    model.fit(X_poly_train, y_train)

    # Predict the values for train and test sets
    y_pred_train = model.predict(X_poly_train)
    y_pred_test = model.predict(X_poly_test)

    # Calculate R² scores
    r2_train = r2_score(y_train, y_pred_train)
    r2_test = r2_score(y_test, y_pred_test)

    # Plot the fitted curve
    plt.plot(X_normalized, model.predict(polynomial_features.transform(X_normalized)), color=color, linewidth=2,
             label=f'Degree {degree} (Train R²={r2_train:.2f}, Test R²={r2_test:.2f})')

# Add labels and title to the plot
plt.xlabel('X')
plt.ylabel('y')
plt.title('Polynomial Regression - Overfitting Example (Normalized)')
plt.legend(loc='upper left')

# Display the plot
plt.show()

В этом обновленном коде данные сначала нормализуются путем вычитания среднего значения и деления на стандартное отклонение. Затем данные разбиваются на набор поездов (80% данных) и тестовый набор (20% данных) с использованием train_test_split() из scikit-learn.

Модели полиномиальной регрессии аппроксимируются с использованием нормализованных обучающих данных, а оценки R² рассчитываются как для обучающих, так и для тестовых наборов с использованием r2_score() из scikit-learn. Затем баллы R² отображаются в легенде каждой подобранной кривой.

Нормализуя данные и вычисляя баллы R² как для обучающего, так и для тестового наборов, вы можете оценить производительность моделей полиномиальной регрессии и определить, подходят ли они или хорошо обобщают невидимые данные.

В этом случае мы получаем:

Итак, что мы получили? Что ж… Мы не видим явных признаков переобучения, потому что R² немного увеличивается для полинома 4-й степени в тестовом наборе, а для полинома 15-й степени — немного уменьшается.

Здесь ошибка в том, что мы продолжили начатый чат. Давайте вспомним, что LLM — это нейронные сети, и они имеют тенденцию к переоснащению. Итак, иногда, если вы просто продолжаете подсказывать, вы получаете тот же ответ (или что-то очень похожее), даже если он возвращает вам некоторые «извинения за ошибку».

Кроме того, я не хочу никакого сюжета. Так что в этом случае нам лучше создать еще один чат. Теперь давайте попробуем уточнить». Создайте набор данных с двумя степенями в Python. Нормализуйте данные и разделите их на поезд и тестовый набор. Сопоставьте данные с: линейной регрессией, полиномиальными моделями 4-степени и полиномиальными моделями 15-степени. Выведите r-квадрат для каждой модели как для обучающей, так и для тестовой выборки».

И мы получаем:

Чтобы создать набор данных с двумя степенями в Python, нормализовать его и разделить на обучающие и тестовые наборы, вы можете использовать библиотеки numpy и sklearn. Вот пример того, как вы можете этого добиться:

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

# Create the dataset
X = np.random.rand(100, 1)  # Independent variable
y = 3 * X**2 + np.random.randn(100, 1)  # Dependent variable (quadratic relationship)

# Normalize the data
X_normalized = (X - np.mean(X)) / np.std(X)
y_normalized = (y - np.mean(y)) / np.std(y)

# Split the data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X_normalized, y_normalized, test_size=0.2, random_state=42)

# Fit the linear regression model
linear_regression = LinearRegression()
linear_regression.fit(X_train, y_train)

# Fit the 4-degree polynomial regression model
poly_features = PolynomialFeatures(degree=4)
X_poly_train = poly_features.fit_transform(X_train)
X_poly_test = poly_features.transform(X_test)
poly_regression = LinearRegression()
poly_regression.fit(X_poly_train, y_train)

# Fit the 15-degree polynomial regression model
poly_features = PolynomialFeatures(degree=15)
X_poly_train = poly_features.fit_transform(X_train)
X_poly_test = poly_features.transform(X_test)
poly_regression_15 = LinearRegression()
poly_regression_15.fit(X_poly_train, y_train)

# Calculate R-squared for train and test sets
linear_train_r2 = linear_regression.score(X_train, y_train)
linear_test_r2 = linear_regression.score(X_test, y_test)

poly_train_r2 = poly_regression.score(X_poly_train, y_train)
poly_test_r2 = poly_regression.score(X_poly_test, y_test)

polysklearn.preprocessingtrain_r2 = poly_regression_15.score(X_poly_train, y_train)
polysklearn.preprocessingtest_r2 = poly_regression_15.score(X_poly_test, y_test)

# Print the results
print("Linear Regression R-squared (Train):", linear_train_r2)
print("Linear Regression R-squared (Test):", linear_test_r2)

print("4-Degree Polynomial Regression R-squared (Train):", poly_train_r2)
print("4-Degree Polynomial Regression R-squared (Test):", poly_test_r2)

print("15-Degree Polynomial Regression R-squared (Train):", polysklearn.preprocessingtrain_r2)
print("15-Degree Polynomial Regression R-squared (Test):", polysklearn.preprocessingtest_r2)

В этом примере мы генерируем набор случайных данных с квадратичной зависимостью между независимой переменной X и зависимой переменной y. Затем данные нормализуются с использованием нормализации z-оценки. Затем набор данных разбивается на набор поездов (80%) и набор тестов (20%) с использованием train_test_split из модуля sklearn.model_selection.

Затем мы подогнали три разные модели: линейную регрессию, полиномиальную регрессию 4-й степени и полиномиальную регрессию 15-й степени. Для полиномиальной регрессии мы используем класс PolynomialFeatures из sklearn.preprocessing для создания полиномиальных функций до желаемой степени. Модели подобраны с использованием нормализованных обучающих данных.

Наконец, мы вычисляем значение R-квадрата как для поезда, так и для тестовых наборов для каждой модели, используя метод score соответствующих моделей. Значение R-квадрата представляет долю дисперсии зависимой переменной, которая может быть объяснена

Итак, мы получили то, что хотели, и с некоторыми пояснениями. Теперь, если мы попробуем, мы получим:

ValueError: X has 16 features, but LinearRegression
is expecting 5 features as input.

Опс! Как мы уже говорили, могут возникнуть некоторые ошибки. Таким образом, в этих случаях мы можем просто продолжить чат следующим образом: «Я получаю: ValueError: X имеет 16 функций, но линейная регрессия ожидает 5 функций в качестве входных данных».

И теперь он возвращается:

Приносим извинения за ошибку. Похоже, возникла проблема с преобразованием полиномиальных признаков. Чтобы решить эту проблему, нам нужно убедиться, что мы применяем полиномиальное преобразование к нормализованным данным X, а не к исходным данным X. Вот исправленный код:

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

# Create the dataset
X = np.random.rand(100, 1)  # Independent variable
y = 3 * X**2 + np.random.randn(100, 1)  # Dependent variable (quadratic relationship)

# Normalize the data
X_normalized = (X - np.mean(X)) / np.std(X)
y_normalized = (y - np.mean(y)) / np.std(y)

# Split the data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X_normalized, y_normalized, test_size=0.2, random_state=42)

# Fit the linear regression model
linear_regression = LinearRegression()
linear_regression.fit(X_train, y_train)

# Fit the 4-degree polynomial regression model
poly_features = PolynomialFeatures(degree=4)
X_poly_train = poly_features.fit_transform(X_train)
X_poly_test = poly_features.transform(X_test)
poly_regression = LinearRegression()
poly_regression.fit(X_poly_train, y_train)

# Fit the 15-degree polynomial regression model
poly_features_15 = PolynomialFeatures(degree=15)
X_poly_train_15 = poly_features_15.fit_transform(X_train)
X_poly_test_15 = poly_features_15.transform(X_test)
poly_regression_15 = LinearRegression()
poly_regression_15.fit(X_poly_train_15, y_train)

# Calculate R-squared for train and test sets
linear_train_r2 = linear_regression.score(X_train, y_train)
linear_test_r2 = linear_regression.score(X_test, y_test)

poly_train_r2 = poly_regression.score(X_poly_train, y_train)
poly_test_r2 = poly_regression.score(X_poly_test, y_test)

polysklearn.preprocessingtrain_r2 = poly_regression_15.score(X_poly_train_15, y_train)
polysklearn.preprocessingtest_r2 = poly_regression_15.score(X_poly_test_15, y_test)

# Print the results
print("Linear Regression R-squared (Train):", linear_train_r2)
print("Linear Regression R-squared (Test):", linear_test_r2)

print("4-Degree Polynomial Regression R-squared (Train):", poly_train_r2)
print("4-Degree Polynomial Regression R-squared (Test):", poly_test_r2)

print("15-Degree Polynomial Regression R-squared (Train):", polysklearn.preprocessingtrain_r2)
print("15-Degree Polynomial Regression R-squared (Test):", polysklearn.preprocessingtest_r2)

Теперь код должен работать правильно, применяя полиномиальное преобразование к нормализованным данным и соответствующим образом подгоняя модели.

Теперь, если мы проверим это, мы получим:

Linear Regression R-squared (Train): 0.5287297254229243
Linear Regression R-squared (Test): 0.4627146369316367

4-Degree Polynomial Regression R-squared (Train): 0.5895312356444804
4-Degree Polynomial Regression R-squared (Test): 0.4601670183046247

15-Degree Polynomial Regression R-squared (Train): 0.6256705123172766
15-Degree Polynomial Regression R-squared (Test): 0.26972190687190367

Итак, здесь мы видим небольшое переоснащение 4-градусной модели и явное переоснащение 15-градусной модели. На самом деле, чем выше степень полинома, тем выше вероятность того, что он соответствует данным. Давайте подумаем об этом: у нас есть распределение данных с 2 степенями, и мы пытаемся сопоставить его с полиномом 15 степеней. Итак, легко понять, что 15-градусный полином может захватывать каждую маленькую модификацию данных, что приводит к переоснащению.

Выводы

В этой статье мы увидели важность оперативной разработки сегодня, как она может повлиять на специалистов по данным, а также несколько примеров быстрых действий для специалистов по данным.

Помните, что подсказка должна быть короткой и ясной, и что мы всегда должны проверять ответы. Но, как мы показали, преимущества огромны.

БЕСПЛАТНАЯ ЭЛЕКТРОННАЯ КНИГА О ПАНДАХ:

Начали изучать Data Science с Python? Подпишитесь на мою рассылку и получите мою бесплатную электронную книгу о пандах: вы узнаете о пандах на практических примерах.

Понравилась история? Станьте участником Medium за 5$/месяц по моей реферальной ссылке: я заработаю небольшую комиссию без дополнительной платы для вас: