Featuretools, HeadJackai, автоподвиг
Что такое функциональная инженерия?
Вообще говоря, стандартный процесс машинного обучения состоит из четырех этапов: предварительная обработка данных, проектирование признаков, обучение модели и проверка результатов. Разработка признаков — важная часть процесса, в котором специалисты по данным извлекают или организуют данные, используя знания предметной области, чтобы повысить производительность моделей машинного обучения. На практике качество разработки признаков определяет верхний предел возможности прогнозирования. Однако это зависит от понимания специалистом по данным предметной области и прошлого опыта.
Что такое автоматическая разработка признаков?
Вышеупомянутый процесс работает гладко, если нам нужно построить только несколько моделей машинного обучения и нет ограничений по времени. Однако реальность такова, что мы должны построить несколько моделей в течение ограниченного времени, и их построили разные специалисты по данным. Чтобы обеспечить стабильные результаты в этой ситуации, необходимо быстро построить отличные модели в качестве базовых для каждой задачи. Чтобы еще больше повысить производительность этих моделей, можно добавить ручные функции на основе базовой модели, чтобы уменьшить погрешность.
Что касается того, как быстро создавать отличные базовые модели машинного обучения, в настоящее время есть два основных решения: одно — решать со стороны модели, что в основном включает автоматическую настройку гиперпараметров. Модель машинного обучения обычно имеет много различных типов гиперпараметров, и этот метод может помочь вам выбрать правильную комбинацию из широкого спектра гиперпараметров. Во-вторых, решить со стороны функции, что является основным направлением этой статьи.
Автоматизированная разработка признаков — это процесс использования алгоритмов и методов для автоматического извлечения и создания признаков из необработанных данных. По сравнению с ручным проектированием признаков, метод автоматизированного проектирования признаков более универсален, так что алгоритм можно применять к широкому диапазону типов данных и областей, что делает его гибким инструментом для использования в различных областях, поскольку он не всегда можно предвидеть, какие типы данных будут использоваться в дальнейшем при проектировании. Хороший автоматизированный метод разработки признаков может дать специалистам по данным несколько преимуществ:
- высокая скорость, сокращающая время ручного майнинга функций
- стабильное улучшение, снижающее ограничения личных знаний специалистов по данным
- человеко-машинная интеграция, повышающая эффективность и может использоваться с отличными ручными функциями
- что позволяет быстро корректировать методы разработки признаков в онлайн-обучении машин без частого ручного ремонта.
Наиболее часто используемые автоматизированные методы разработки признаков — это Deep Feature Synthesis (DFS) и AutoCross. Известный пакет Python Featuretools использует DFS в качестве метода создания функций, при этом основной принцип заключается в автоматическом объединении и объединении функций для реляционных данных. Другим часто встречающимся методом является AutoCross, предложенный в 4Paradigm, который использует стратегию поиска луча для создания эффективных комбинаций признаков и может генерировать явные признаки более высокого порядка (2-го порядка и выше). Однако объекты, созданные этими методами, в основном ограничены перекрестными объектами, то есть генерируются с помощью таких вычислений, как сложение, вычитание, умножение и деление двух разных объектов. Метод генерации признаков, представленный в этой статье, отличается от явных методов и использует модель, обученную на распределении других наборов данных посредством преобразования признаков».
ХЕДДЖЕК
HEADJACK (HJ) — это платформа преобразования функций, специально разработанная для машинного обучения. На платформе есть много участников, которые создали предварительно обученные модели объектов (в настоящее время ограничены структурированными данными), которые вы можете создать самостоятельно или использовать созданные другими. Основной дух этой платформы — делиться функциями, объединять данные со всего мира. Одна модель признаков представляет один метод разработки признаков, и этот метод разработки признаков не ограничивается обработкой определенных типов столбцов. Например, на платформе есть функциональная модель под названием «WNBA-team-stats», которую я хочу использовать для данных UCI Boston House Price. Обычно эти два набора данных не имеют одного и того же ключевого столбца для соединения, поэтому их нельзя соединить друг с другом. Однако в рамках этой платформы этого легко добиться, как показано ниже:
Одни данные могут генерировать один метод разработки признаков, а данные также могут генерировать несколько методов разработки признаков на основе разных методов разделения. Другими словами, мы можем мгновенно получить тысячи методов разработки признаков, а создание признаков изменилось с опоры на ручное знание предметной области на знание данных или знание алгоритмов.
Сравнение различных библиотек проектирования функций
Мы сравниваем featuretools, autofeat и HJ, три инструмента разработки признаков, используя набор данных UCI Boston House Price и вычисляя среднюю абсолютную ошибку на cv-5, и используем lgbm без настройки гиперпараметров. Загрузка данных UCI Boston House Price:
# load UCI boston dataset
from sklearn.datasets import load_boston
from sklearn.model_selection import KFold
from sklearn.metrics import mean_absolute_error
import lightgbm as lgbm
import numpy as np
import featuretools as ft
from headjackai.headjackai_hub import headjackai_hub
from autofeat import AutoFeatRegressor
df = load_boston()
pd_df = pd.concat((pd.DataFrame(df['data']), pd.DataFrame(df['target'])),1)
pd_df.columns = df['feature_names'].tolist()+['label']
X = pd_df.drop('label',1)
y= pd_df['label']
Без использования какого-либо инструмента разработки функций мы напрямую используем lgbm для обучения в качестве базовой модели и получаем MAE 2,25:
# baseline model experiment
N_SPLITS = 5
strat_kf = KFold(n_splits=N_SPLITS, shuffle=True, random_state=8888)
tr_scores = np.empty(N_SPLITS)
scores = np.empty(N_SPLITS)
for idx, (train_idx, test_idx) in enumerate(strat_kf.split(X, y)):
X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
y_train, y_test = y[train_idx], y[test_idx]
cb_clf = lgbm.LGBMRegressor()
cb_clf.fit(X_train,y_train)
preds = cb_clf.predict(X_test)
loss = mean_absolute_error(y_test, preds)
scores[idx] = loss
preds = cb_clf.predict(X_train)
loss = mean_absolute_error(y_train, preds)
tr_scores[idx] = loss
print(f"mean score: {tr_scores.mean():.5f}")
print(f"mean score: {scores.mean():.5f}")
# mean score: 0.89057
# mean score: 2.25251
автопобеда
# autofeat experiemnt
for i in range(2):
N_SPLITS = 5
strat_kf = KFold(n_splits=N_SPLITS, shuffle=True, random_state=8888)
tr_scores = np.empty(N_SPLITS)
scores = np.empty(N_SPLITS)
for idx, (train_idx, test_idx) in enumerate(strat_kf.split(X, y)):
model = AutoFeatRegressor(feateng_steps=i)
X_train, X_test = X.iloc[train_idx], X.iloc[test_idx]
y_train, y_test = y[train_idx], y[test_idx]
X_train = model.fit_transform(X_train, y_train)
X_test = model.transform(X_test)
cb_clf = lgbm.LGBMRegressor()
cb_clf.fit(X_train,y_train)
preds = cb_clf.predict(X_test)
loss = mean_absolute_error(y_test, preds)
scores[idx] = loss
preds = cb_clf.predict(X_train)
loss = mean_absolute_error(y_train, preds)
tr_scores[idx] = loss
print(i)
print(f"mean score: {tr_scores.mean():.5f}")
print(f"mean score: {scores.mean():.5f}")
# 0
# mean score: 0.89057
# mean score: 2.25251
# 1
# mean score: 0.87394
# mean score: 2.23711
# 2
# mean score: 0.68276
# mean score: 2.29572
Инструменты
# featuretools experiment
#featuretools setting
N_SPLITS = 5
strat_kf = KFold(n_splits=N_SPLITS, shuffle=True, random_state=8888)
tr_scores = np.empty(N_SPLITS)
scores = np.empty(N_SPLITS)
trans_primitives=['add_numeric', 'subtract_numeric', 'multiply_numeric', 'divide_numeric']
es.entity_from_dataframe(entity_id='boston',
dataframe=X,
index='index',
make_index=True)
feature_matrix, feature_names = ft.dfs(entityset=es,
target_entity='boston',
max_depth=1,
verbose=0,
trans_primitives=trans_primitives
)
#cv-5, mae, lgbm
for idx, (train_idx, test_idx) in enumerate(strat_kf.split(X, y)):
X_train, X_test = feature_matrix.iloc[train_idx], feature_matrix.iloc[test_idx]
y_train, y_test = y[train_idx], y[test_idx]
cb_clf = lgbm.LGBMRegressor()
cb_clf.fit(X_train,y_train)
preds = cb_clf.predict(X_test)
loss = mean_absolute_error(y_test, preds)
scores[idx] = loss
preds = cb_clf.predict(X_train)
loss = mean_absolute_error(y_train, preds)
tr_scores[idx] = loss
print(f"mean score: {tr_scores.mean():.5f}")
print(f"mean score: {scores.mean():.5f}")
#mean score: 0.42477
#mean score: 2.15799
В библиотеке HJ преобразование функций требует создания учетной записи и предварительного обучения модели, что упрощает пользователям управление функциями и их преобразование. Все это бесплатно. Однако для удобства мы предоставляем здесь учетную запись и предварительно обученные модели функций. Если вы хотите иметь свою учетную запись и модель функций, вы можете создать новую на сайте HJ (или см. Введение и руководство). В эксперименте мы используем тот же метод, что и раньше, используя MAE на cv-5 для тестирования модели lgbm, и попробуем каждую модель функций, предоставленную HJ.
# headjaack experiment
#host setting
hj_hub = headjackai_hub('http://www.headjackai.com:9000')
#account login
hj_hub.login(username='jimliu_medium', pwd='jimliu_medium')
pool_list = hj_hub.knowledgepool_check(True)
score_list = []
task_list = []
# try each feature model
for source in pool_list:
hj_X = hj_hub.knowledge_transform(data=X, target_domain='boston_comparsion',
source_domain=source,
label='')
N_SPLITS = 5
strat_kf = KFold(n_splits=N_SPLITS, shuffle=True, random_state=8888)
tr_scores = np.empty(N_SPLITS)
scores = np.empty(N_SPLITS)
try:
# cv-5, lgbm, mae
for idx, (train_idx, test_idx) in enumerate(strat_kf.split(X, y)):
X_train, X_test = hj_X.iloc[train_idx], hj_X.iloc[test_idx]
y_train, y_test = y[train_idx], y[test_idx]
cb_clf = lgbm.LGBMRegressor()
cb_clf.fit(X_train,y_train)
preds = cb_clf.predict(X_test)
loss = mean_absolute_error(y_test, preds)
scores[idx] = loss
preds = cb_clf.predict(X_train)
loss = mean_absolute_error(y_train, preds)
tr_scores[idx] = loss
print("-----------------",source,"-----------------")
print(f"mean score: {tr_scores.mean():.5f}")
print(f"mean score: {scores.mean():.5f}")
score_list.append(scores.mean())
task_list.append(source)
except:
pass
arg_index = score_list.index(min(score_list))
print(task_list[arg_index], min(score_list))
# ames-house 2.1316169625933044
Согласно результатам нашего эксперимента, в тех же условиях, по сравнению с базовой моделью, все библиотеки разработки функций в этом эксперименте могут улучшить результаты, autofeat улучшается на 1 %, Featuretools улучшается на 4,2 %, а HJ – на 5,3 %, с лучшим улучшением при применении в модели признаков дома Эймса. Более того, в отличие от других алгоритмов разработки признаков, по мере того, как сообщество HJ будет продолжать расти в будущем, у пользователей будет больше моделей признаков, и появится больше возможностей для получения более качественных признаков для повышения эффективности машинного обучения.
HJ, как и другие библиотеки разработки функций, создает функции для экономии времени специалистов по данным. Однако HJ позволяет создавать модели объектов из разных данных, которые затем можно использовать для создания объектов, а не для создания объектов путем выполнения вычислений на объектах необработанных данных. Это делает функции более разнообразными, а также позволяет соединять и использовать множество наборов данных, даже если они не имеют одного и того же ключевого столбца.
