Feature-Engine - это библиотека Python с открытым исходным кодом, содержащая наиболее исчерпывающий набор преобразователей для разработки функций для использования в моделях машинного обучения. Feature-Engine упрощает и оптимизирует реализацию и непрерывный конвейер разработки функций, позволяя выбирать подмножества функций в своих преобразователях и возвращать фреймы данных для облегчения исследования данных. Преобразователи Feature-Engine сохраняют функциональность Scikit-learn с помощью методов fit () и transform () для изучения параметров и последующего преобразования данных.

Функциональная инженерия

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

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

Для получения дополнительной информации о методах разработки функций посетите:



Разработка функций для машинного обучения: всесторонний обзор
Откройте для себя популярные и нишевые методы разработки функций для преобразования переменных и создания более прогностической машины… trainindata.medium.com



Вы также можете найти дополнительную информацию здесь:

Проблемы развертывания конвейера машинного обучения

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

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

Для получения дополнительной информации о том, как оптимизировать конвейеры развертывания с открытым исходным кодом, ознакомьтесь с нашей статьей:



Оптимизация конвейеров разработки функций с помощью движка функций
Узнайте о проблемах, возникающих при разработке конвейеров машинного обучения для развертывания, и узнайте, как с открытым исходным кодом… кdatascience.com



Feature-engine

Feature-engine - это библиотека Python с открытым исходным кодом, которая упрощает и оптимизирует реализацию и непрерывный конвейер разработки функций. Механизм функций сохраняет функциональность Scikit-learn с помощью методов fit () и transform () для изучения параметров и последующего преобразования данных.

Многие методы проектирования функций требуют изучения параметров из данных, таких как статистические значения или сопоставления кодирования, для преобразования входящих данных. Функциональность Scikit-learn с методами подгонки и преобразования упрощает использование и изучение Feature-Engine. Преобразователи Feature-Engine также хранят изученные параметры и могут использоваться в конвейере Scikit-learn.

Механизм функций поддерживает несколько преобразователей для вменения недостающих данных, кодирования категориальных переменных, дискретизации, преобразования переменных и обработки выбросов, обеспечивая, таким образом, наиболее исчерпывающий набор методов для разработки функций. В частности, Feature-Engine поддерживает следующие методы для каждого инженерного аспекта переменной:

Вменение отсутствующих данных

Категориальная кодировка

  • Одно горячее кодирование: OneHotEncoder
  • Одно горячее кодирование часто используемых категорий: OneHotEncoder (Эксклюзив)
  • Кодировка частоты или количества: CountFrequencyEncoder (Эксклюзивный)
  • Порядковая кодировка: OrdinalEncoder
  • Монотонная порядковая кодировка: OrdinalEncoder (Exclusive)
  • Целевое среднее кодирование: MeanEncoder
  • Вес доказательств: WoEEncoder
  • Коэффициент вероятности: PRatioEncoder (эксклюзивно)
  • Группировка редких этикеток: RareLabelEncoder (Эксклюзив)
  • Заменить категории выводом дерева решений: DecisionTreeEncoder (Exclusive)

Методы дискретизации

Методы преобразования переменных

Методы обработки выбросов (эксклюзивные)

Создание функции

  • Сочетание нескольких функций с математическими операциями: MathematicalCombination (Эксклюзив)
  • Комбинация нескольких функций с эталонным значением: CombineWithReferenceFeature (Эксклюзив)

Выбор функции

В чем уникальность Feature-Engine?

Feature-engine имеет следующие характеристики, которые отличают его от других доступных пакетов с открытым исходным кодом:

  1. Feature-Engine содержит самую исчерпывающую батарею инженерных преобразований функций.
  2. Feature-engine позволяет нам выбирать переменные для преобразования в преобразователе.
  3. Механизм функций принимает фрейм данных и возвращает фрейм данных, подходящий как для исследования данных, так и для производства или развертывания.
  4. Feature-engine совместим с конвейером Scikit-learn, поэтому все инженерные преобразования могут быть сохранены в одном файле Python pickle.
  5. Feature-Engine автоматически распознает числовые и категориальные переменные
  6. Механизм функций будет предупреждать, когда преобразования невозможны, например, при применении логарифма к отрицательным переменным или делению на переменные с 0 в качестве значений.

Исчерпывающий набор инструментов преобразования переменных Feature-Engine

Механизм функций выполняет всесторонние преобразования, чтобы данные были готовы для машинного обучения. В дополнение к широко используемым методам вменения, таким как среднее, медианное, режим и произвольное вменение, которые также поддерживаются Scikit-learn, Feature-engine также поддерживает вменение со значениями в конце распределения и вменение с помощью случайной выборки. ».

Feature-Engine также предлагает множество эксклюзивных техник для кодирования категориальных переменных. Помимо широко используемого горячего кодирования и порядкового номера, поддерживаемого Scikit-learn, а также целевого среднего кодирования и веса свидетельств, поддерживаемых кодировщиками категорий, Feature-Engine также предлагает подсчет и частотное кодирование, монотонное кодирование. порядковое кодирование, » кодирование отношения вероятностей и кодирование деревьями решений .

Feature-engine также предлагает функции для обработки редких меток, например, горячее кодирование часто встречающихся категорий или группирование нечастых категорий под общей новой меткой, определяемой пользователем.

Механизм функций содержит большинство математических преобразований и методов дискретизации, доступных в Scikit-learn, и имеет дополнительную функциональность для использования деревьев решений для преобразования переменной в дискретные числа. Наконец, Feature-engine, насколько нам известно, единственная библиотека с открытым исходным кодом с функцией удаления или цензуры выбросов.

В одном из последних выпусков Feature-engine включал обширную батарею инструментов выбора функций в дополнение к уже доступным в Scikit-learn, предоставляя гибридные методы выбора функций, разработанные в отрасли или заявленные на соревнованиях по науке о данных.

Механизм функций позволяет выбирать переменные в трансформаторе

Одна из причин, по которой преобразователи Feature-Engine настолько удобны, заключается в том, что они позволяют нам выбирать, какие переменные мы хотим преобразовать с помощью каждого метода, непосредственно на преобразователе.

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

Feature-Engine возвращает фрейм данных

Все преобразователи Feature-Engine возвращают фреймы данных в качестве выходных данных. Это означает, что после преобразования нашего набора данных нам не нужно беспокоиться об именах переменных и порядке столбцов, как это было бы с массивами NumPy, возвращаемыми Scikit-learn.

С Feature-Engine мы можем продолжать использовать возможности pandas для анализа и визуализации данных даже после преобразования нашего набора данных, что позволяет исследовать данные до и после преобразования переменных.

Feature-engine совместим с конвейером Scikit-learn.

Преобразователи Feature-Engine совместимы с конвейером Scikit-learn. Это позволяет реализовать множество этапов разработки функций в рамках единого конвейера Scikit-learn до обучения алгоритма машинного обучения или получения его прогнозов на основе необработанных данных.

С помощью Feature-Engine мы можем сохранить всю серию преобразований машинного обучения в один объект, который можно сохранить и получить на более позднем этапе или поместить в память для оценки в реальном времени. Примеры кода далее в этой статье.

Feature-Engine автоматически распознает числовые и категориальные переменные

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

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

Предупреждения механизма функций, когда преобразования для определенных переменных невозможны

Feature-Engine предупредит, когда преобразования невозможны. Например, для категориального кодирования Feature-engine сигнализирует о неожиданном / непреднамеренном введении пропущенных значений. Для преобразований переменных Feature-engine будет предупреждать, когда логарифм применяется к отрицательным переменным или когда обратные преобразования применяются к переменным с нулями в качестве значений.

Таким образом, Feature-Engine помогает выявлять проблемы с переменными на ранней стадии разработки инженерного конвейера машинного обучения, чтобы мы могли выбрать более подходящий метод.

Как использовать Feature-Engine

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

Преобразователи механизма функций изучают параметры из данных, когда используется метод fit (), и сохраняют эти параметры в своих атрибутах. Затем эти значения могут быть извлечены для преобразования новых данных. В следующих разделах мы покажем, как создать экземпляр и подогнать трансформатор, а также как использовать обученный трансформатор для преобразования поезда и тестового набора.

Вменение отсутствующих данных

Вменение отсутствующих данных означает замену отсутствующих наблюдений статистическим параметром, полученным из имеющихся значений переменной. В качестве примера возможности вменения Feature-Engine мы выполним вменение медианного значения. MeanMedianImputer механизма Feature автоматически выбирает все числовые переменные в наборе данных для вменения, игнорируя категориальные переменные. Преобразователь также предлагает возможность выбора переменных для вменения, как мы покажем ниже.

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

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

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from feature_engine.imputation import MeanMedianImputer

# Load dataset
data = pd.read_csv('creditApprovalUCI.csv')
 
# Separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(
    data.drop('A16', axis=1),
    data['A16'],
    test_size=0.3,
    random_state=0
    )
 
# Set up the imputer
median_imputer = MeanMedianImputer(
    imputation_method='median',
    variables=[‘A2’, ‘A3’, ‘A8’, ‘A11’, ‘A15’]
    )
# fit the imputer
median_imputer.fit(X_train)
 
# transform the data
X_train = median_imputer.transform(X_train)
X_test = median_imputer.transform(X_test)

После выполнения приведенного выше кода обучающий набор не будет содержать пропущенных значений в переменных A2, A3, A8, A11 и A15, а на выходе будет фрейм данных, который позволит нам продолжить исследование данных, например, чтобы понять эффект этого преобразования в распределении переменных.

Категориальная кодировка

Категориальное кодирование включает методы преобразования переменных, содержащих строки в качестве значений, в числовые переменные. Чтобы продемонстрировать, как использовать категориальные кодировщики Feature-engine, мы выполним кодирование Count, то есть заменим категории на количество раз, которое они появляются в наборе поездов. Мы будем использовать титанический набор данных, который публично доступен в OpenML.

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from feature_engine import encoding as ce
 
# Load dataset
def load_titanic():
  data = pd.read_csv(
      'https://www.openml.org/data/get_csv/16826755  /phpMYEkMl'
       )
  data = data.replace('?', np.nan)
  data['cabin'] = data['cabin'].astype(str).str[0]
  data['pclass'] = data['pclass'].astype('O')
  data['embarked'].fillna('C', inplace=True)
  return data
 
data = load_titanic()
 
# Separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(
  data.drop(['survived', 'name', 'ticket'], axis=1),
  data['survived'], test_size=0.3, random_state=0
  )
 
# set up the encoder
encoder = ce.CountFrequencyEncoder(
        encoding_method='frequency',
        variables=['cabin', 'pclass', 'embarked']
        )
 
# fit the encoder
encoder.fit(X_train)
 
# transform the data
train_t = encoder.transform(X_train)
test_t = encoder.transform(X_test)

Механизм функций изучает сопоставления категорий и строк из набора поездов и сохраняет их в атрибуте encoder_dict_. Результатом является фрейм данных, в котором переменные cabin, pclass и embarked теперь являются числами, а не строками.

Дискретность

Дискретизация включает в себя сортировку значений непрерывных переменных по дискретным интервалам, также называемым ячейками или корзинами. Здесь мы покажем, как выполнить дискретизацию с использованием деревьев решений, методику, поддерживаемую исключительно Feature-engine.

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

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from feature_engine import discretisation as dsc
 
# Load dataset
data = data = pd.read_csv('houseprice.csv')
 
# Separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(
 data.drop(['Id', 'SalePrice'], axis=1),
 data['SalePrice'],
 test_size=0.3,
 random_state=0
 )
 
# set up the discretisation transformer
disc = dsc.DecisionTreeDiscretiser(
    cv=3,
    scoring='neg_mean_squared_error',
    variables=['LotArea', 'GrLivArea'],
    regression=True
    )
 
# fit the transformer
disc.fit(X_train, y_train)
 
# transform the data
train_t = disc.transform(X_train)
test_t = disc.transform(X_test)

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

Математическое преобразование

Математические преобразования относятся к преобразованию исходной переменной с применением любой математической функции, как правило, чтобы попытаться получить гауссово распределение. Здесь мы продемонстрируем, как реализовать преобразование Бокса-Кокса с помощью Feature-engine:

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from feature_engine import transformation as vt
 
# Load dataset
data = data = pd.read_csv('houseprice.csv')
 
# Separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(
  data.drop(['Id', 'SalePrice'], axis=1),
 data['SalePrice'],
 test_size=0.3,
 random_state=0
 )
 
# set up the variable transformer
tf = vt.BoxCoxTransformer(
    variables = ['LotArea', 'GrLivArea']
    )
 
# fit the transformer
tf.fit(X_train)
 
# transform the data
train_t = tf.transform(X_train)
test_t = tf.transform(X_test)

Обработка выбросов

Выбросы - это те переменные переменной, которые чрезвычайно необычны для остальных значений указанной переменной. Среди своих функций Feature-engine позволяет нам удалять или подвергать цензуре выбросы на основе приближения Гаусса, правила близости межквартильного диапазона или процентилей. Здесь мы продемонстрируем, как цензурировать выбросы, определяя пределы переменных с помощью IQR:

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from feature_engine import outlier as outr
 
# Load dataset
def load_titanic():
   data = pd.read_csv(
    'https://www.openml.org/data/get_csv/16826755/phpMYEkMl'
   )
   data = data.replace('?', np.nan)
   data['cabin'] = data['cabin'].astype(str).str[0]
   data['pclass'] = data['pclass'].astype('O')
   data['embarked'].fillna('C', inplace=True)
   data['fare'] = data['fare'].astype('float')
   data['fare'].fillna(data['fare'].median(), inplace=True)
   data['age'] = data['age'].astype('float')
   data['age'].fillna(data['age'].median(), inplace=True)
   return data
 
data = load_titanic()
 
# Separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(
  data.drop(['survived', 'name', 'ticket'], axis=1),
  data['survived'],
  test_size=0.3,
  random_state=0
  )
 
# set up the capper
capper = outr.Winsorizer(
  distribution='gaussian',
  tail='right',
  fold=3,
  variables=['age', 'fare']
  )
 
 # fit the capper
 capper.fit(X_train)
 
 # transform the data
 train_t = capper.transform(X_train)
 test_t = capper.transform(X_test)

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

Сборка преобразователей Feature-Engine в конвейер Scikit-learn

В предыдущих разделах мы показали, как реализовать каждую технику индивидуально. Когда мы строим модели машинного обучения, мы обычно выполняем различные преобразования переменных. Мы можем разместить все преобразователи Feature-Engine в конвейере обучения Scikit, чтобы сгладить преобразование данных и обучение алгоритмов, а также легко оценивать новые необработанные данные.

В следующем фрагменте кода мы выполняем полный конвейер разработки функций для набора данных о ценах на жилье, а затем строим регрессию Лассо для прогнозирования цены на жилье, используя возможности конвейера Scikit-learn:

import pandas as pd
import numpy as np
 
from sklearn.linear_model import Lasso
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline as pipe
from sklearn.preprocessing import MinMaxScaler
 
from feature_engine import encoding as ce
from feature_engine import discretisation as dsc
from feature_engine import imputation as mdi
 
# load dataset
data = pd.read_csv('houseprice.csv')
 
# drop some variables
data.drop(
   labels=['YearBuilt', 'YearRemodAdd', 'GarageYrBlt', 'Id'],
   axis=1,
   inplace=True
   )
 
# make a list of categorical variables
categorical = [
   var for var in data.columns if data[var].dtype == 'O'
]
 
# make a list of numerical variables
numerical = [
   var for var in data.columns if data[var].dtype != 'O'
]
 
# make a list of discrete variables
discrete = [ 
   var for var in numerical if len(data[var].unique()) < 20
]
 
# categorical encoders work only with object type variables
# to treat numerical variables as categorical, we need to 
# re-cast them
data[discrete]= data[discrete].astype('O')
 
# continuous variables
numerical = [
 var for var in numerical if var not in discrete
 and var not in ['Id', 'SalePrice']
 ]
 
# separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(
    data.drop(labels=['SalePrice'], axis=1),
    data.SalePrice,
    test_size=0.1,
    random_state=0
    )
 
# set up the pipeline
price_pipe = pipe([
# add a binary missing indicator
 ('continuous_var_imputer', mdi.AddMissingIndicator(
      variables = ['LotFrontage'])),
 
 # replace NA by the median
 ('continuous_var_median_imputer', mdi.MeanMedianImputer(
      imputation_method='median',
      variables = ['LotFrontage', 'MasVnrArea'])),
 
 # replace NA by adding the label "Missing"
 ('categorical_imputer', mdi.CategoricalVariableImputer(
      variables = categorical)),
 
 # disretise continuous variables using trees
 ('numerical_tree_discretiser', dsc.DecisionTreeDiscretiser(
      cv = 3, 
      scoring='neg_mean_squared_error',
      variables = numerical, regression=True)),
 
 # remove rare labels in categorical and discrete variables
 ('rare_label_encoder', ce.RareLabelCategoricalEncoder(
      tol = 0.03,
      n_categories=1, 
      variables = categorical+discrete)),
 
 # encode categorical and discrete variables using the target mean
 ('categorical_encoder', ce.MeanCategoricalEncoder(
      variables = categorical+discrete)),
 
 # scale features
 ('scaler', MinMaxScaler()),
 
 # Lasso
 ('lasso', Lasso(random_state=2909, alpha=0.005))
 ])
 
 # train feature engineering transformers and Lasso
 price_pipe.fit(X_train, np.log(y_train))
 
 # predict
 pred_train = price_pipe.predict(X_train)
 pred_test = price_pipe.predict(X_test)

Обратите внимание на то, как в приведенном выше коде мы указываем, какие переменные нужно преобразовать в каждом из преобразователей Feature-Engine. Также обратите внимание, насколько легко обучить алгоритм и получить прогнозы, когда все трансформаторы собраны в конвейер. Если мы хотим развернуть этот конвейер, нам нужно только поместить в память 1 объект Python для выполнения работы или сохранить и получить только 1 рассол Python, который содержит весь предварительно обученный конвейер машинного обучения.

Бонус: оболочка Scikit-learn

Трансформаторы Scikit-learn, такие как SimpleImputer или любой из масштабаторов переменных, например StandardScaler или MinMaxScaler, преобразуют весь входной набор данных и возвращают массив NumPy. Если мы хотим применить эти преобразователи к подмножеству функций, мы можем использовать оболочку Scikit-learn, доступную в Feature-engine.

Вот как это сделать:

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from feature_engine.wrappers import SklearnTransformerWrapper
 
# Load dataset
data = pd.read_csv('houseprice.csv')
 
# Separate into train and test sets
X_train, X_test, y_train, y_test = train_test_split(
 data.drop(['Id', 'SalePrice'], axis=1),
 data['SalePrice'],
 test_size=0.3,
 random_state=0
 )
 
# set up the wrapper with the SimpleImputer
imputer = SklearnTransformerWrapper(
    transformer = SimpleImputer(strategy='mean'),
    variables = ['LotFrontage', 'MasVnrArea'])

# fit the wrapper + SimpleImputer
imputer.fit(X_train)
 
# transform the data
X_train = imputer.transform(X_train)
X_test = imputer.transform(X_test)

Оболочки Scikit-learn Feature-Engine позволяют применять большинство преобразователей Scikit-learn к выбранному подпространству функций, возвращая фрейм данных.

Заключительное слово

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

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

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

Дополнительные ресурсы