В этом посте мы будем говорить и решать эту задачу, которая была на конкурсе kaggle год назад, т.е. в 2019 году.
Вот ссылка на конкурс: Нажмите здесь
Мы решим этот кейс Учитесь и старайтесь попасть в топ-5% или даже меньше, используя очень интересные техники.
Обзор тематического исследования:
- Сначала мы рассмотрим описание Конкурса,
- Мы узнаем о механике того, как она выполняется, используя эксперименты, проведенные в лаборатории человека,
- Мы рассмотрим набор данных и проверим его функции,
- Проверьте бизнес-проблему и метрику, указанную для конкурса,
- Каковы существующие проблемы или подходы к этой проблеме,
- Взгляните на набор данных, т. Е. Исследование данных (EDA),
- Проверьте некоторые методы разработки функций,
- Обучите данные и проверьте прогнозы и
- Пойдем!
1. Краткое описание конкурса.
LANL Прогноз землетрясений - это задача прогнозирования возникновения землетрясений, тектонических движений земных слоев. Данные взяты из эксперимента, проведенного на скалах в рамках классической лабораторной модели землетрясения. Лабораторная модель имитирует тектонические разломы в земных слоях. Хотя это более простая версия исходного землетрясения, утверждается, что оно имеет большинство физических характеристик настоящего землетрясения. Данные являются периодическими с реалистичным поведением, что означает, что в данных есть землетрясения, которые происходят нерегулярно.
На данный момент, проверив их описание, я не знаю, как выглядит землетрясение в лаборатории и как оно работает, но видео ниже развеет большинство сомнений, надеюсь.
Цель завершения состоит в том, чтобы предсказать время, когда произойдет землетрясение, в ходе лабораторных испытаний. Смоделированные землетрясения, как правило, происходят периодически, что означает, что они основаны на времени.
Как симуляция работает в этом эксперименте?
В описании конкурса сказано, что данные получены из эксперимента, проведенного на скале с некоторой геометрией для двухосного нагружения, классического лабораторного эксперимента.
Два слоя выпахивания разломов (зернистые) сдвигаются одновременно, подвергаясь постоянной нормальной нагрузке и заданной скорости сдвига. Лабораторные разломы разрушаются в повторяющихся циклах прилипания и проскальзывания, которые призваны имитировать цикл нагрузки и разрушения тектонических разломов. Хотя эксперимент значительно проще, чем разлом на Земле, он имеет много общих физических характеристик.
2. Механика того, как это работает в лабораторных экспериментах
Как может выглядеть землетрясение в лаборатории, посмотрите это видео:
После просмотра видео можно заметить, что через какое-то время зонд раскалывается под некоторым давлением, далее мы видим, что у нас есть 3 вида пластин:
- При нормальном давлении две пластины, левая и правая, действуют под углом 90 градусов к пластине, что толкает две пластины вместе.
- Есть 3-я пластина, которая отделена каким-то материалом, это место может двигаться вниз с некоторой постоянной скоростью.
- «Некоторый материал» может быть каким-то камнем, который можно расколоть и снова нагрузить, чтобы снова и снова вызывать лабораторные землетрясения в повторяющихся циклах.
3. Давайте углубимся в предоставленные данные.
Данные, используемые для обучения модели, представляют собой один непрерывный сегмент экспериментальных данных, состоящий из двух столбцов:
а. Acoustic_data : сейсмические сигналы, имеющие целочисленный тип данных.
б. Time_to_failure: время в секундах, в течение которого должно произойти следующее лабораторное землетрясение. Этот тип данных является плавающим.
Тестовые файлы, из которых должны быть сделаны прогнозы, имеют непрерывные данные, но все тестовые файлы вместе не составляют непрерывный сегмент, как обучающие данные. Они могут быть из разных экспериментов. Всего 2624 тестовых файла.
Для каждого идентификатора сегмента тестовой папки цель состоит в том, чтобы предсказать time_to_failure, т. е. время (в секундах) между последним сегментом и возникновением следующего лабораторного землетрясения.
Данных аж 9.26гб, есть хитрость о которой я вам скажу где скачать можно за секунды или минуты ;)
#After downloading the train data consider following:
train = pd.read_csv("../input/train.csv", nrows=10000000,
dtype={'acoustic_data': np.int16, 'time_to_failure': np.float64})
train.head(5)
Давайте посмотрим на набор данных, обратите внимание, что «acoustic_data» имеет тип int, а «time_to_failure» — это тип float, который уже был задан, поэтому мы рассматриваем его таким образом.
Трюк для загрузки данных в Snap:
Шаг_1: Перейдите в Google, введите расширение CurlWget и добавьте его в Chrome или Firefox.
Шаг_2: Проверьте расширение в правом верхнем углу вашего браузера, теперь оно добавлено в ваш Chrome.
Шаг_3: Теперь для любой загрузки, которую вы делаете, в нашем случае это 9 ГБ, просто загружайте файл, как обычно, НО! отменить загрузку через 2 секунды.
Шаг_4: Проверьте наличие расширения, вы увидите огромный текст, когда вы прокручиваете текст, он говорит, что нажмите, чтобы скопировать.
Шаг_5: Просто скопируйте его и откройте Google Colab, где вы запускаете код, и вставьте его после ввода «!» и запустите ячейку, например:
!<paste_here>
Шаг_6: Теперь потребуется несколько секунд или минут, чтобы загрузить его прямо в ваш контент вашего коллаборации Google! Ура!
4. Метрика для конкурса
Метрика, используемая для оценки, представляет собой среднюю абсолютную ошибку между прогнозируемым временем, оставшимся до следующего лабораторного землетрясения, и фактическим оставшимся временем.
Что такое МАЭ?
Это мера ошибки между парой наблюдений, также называемых предсказанными и фактическими наблюдениями, пусть «y» будет предсказанным, а «x» будет фактическим значением, а «n» будет общим количеством значений или длиной всех точек.
#example using simple values from sklearn.metrics import mean_absolute_error y_true = [3, -0.5, 2, 7] y_pred = [2.5, 0.0, 2, 8] print(mean_absolute_error(y_true, y_pred)) #result will be 0.5
5. Существующие проблемы или пути решения этой проблемы.
В ходе конкурса они предоставили нам базовое ядро бенчмарка для того, чтобы мы могли начать работу, давайте подробно проверим, что в нем есть.
- Они загрузили данные для обучения кадра данных.
- Теперь, для нашего удобства, мы можем выбрать количество строк из train.csv, примеры позволяют взять 100 тыс.
- Давайте разделим данные на куски, обратите внимание, что они не использовали функцию train_test_split, а создали собственную функцию, мы можем взять ее в качестве эталона.
- Для каждого количества строк занавеса, например: 2x, они берут среднее, максимальное, стандартное и минимальное значения и принимают новый фрейм данных X_train,
- То же самое с y_train.
#Example(rough)
rows = 2k
segment = train.shape[0]/ rows # we will get 2k rows in X_train
X_train = pd.Dataframe(...)
y_train = pd.Dataframe(...)
for segment in range(segment):
seg = train.iloc[ segment * rows: segment*rows + rows]
x = seg['acoustic_data'].values
y = seg['time_to_failure'].values[-1]
X_train.loc[segment] = x.mean()
X_train.loc[segment] = x.max()
X_train.loc[segment] = x.min()
X_train.loc[segment] = x.std()
y_train.loc[segment] = y
6. После прохождения X_train и y_train у них были данные StandardScaler() для обучения модели.
7. Затем использовал Sklearn MAE, чтобы показать нам MAE
score = mean_absolute_error(y_train.values.flatten(), y_pred)
print(f'Score: {score}')
#result was 2.314
Вышеупомянутое было дано для использования, чтобы иметь общее представление, и теперь мы можем проверить архитектуру, как мы можем двигаться.
6. Исследовательский анализ данных (EDA)
EDA на данных о поездах
Хорошо, давайте загрузим train.csv с помощью curlwget и загрузим его в наш контент нашего google colab.
!wget --header="..."
Это будет формат zip, чтобы распаковать его в нужное нам содержимое:
!pip install pyunpack
!pip install patool
from pyunpack import Archive
Archive(‘/content/train.csv.zip’).extractall(‘/content’)
#you will see the train.csv to the left in the contents
train = pd.read_csv(‘/content/train.csv’, nrows=6000000,
dtype={‘acoustic_data’: np.int16,
‘time_to_ failure’: np.float64})
train.shape #returns shape will be (6000000, 2)
train.columns
#returns Index(['acoustic_data', 'time_to_failure'], dtype='object')
Давайте проверим наличие нулевых значений в данных.
print(train.acoustic_data.isnull().values.any()) print(train..time_to_failure.isnull().values.any()) #Both will return False
Давайте проверим распределение признаковonic_data, так как 6 миллионов строк являются массивными, мы проверим только 1% от них.
train_sample = train.sample(frac=0.01)
plt.figure(figsize=(10,5))
plt.title("Acoustic data distribution")
ax = sns.distplot(train_sample.acoustic_data, label='Train (1% sample)')
Мы можем видеть, что при грубой случайной выборке строк кажется, что выбросы есть в обоих направлениях, давайте проверим распределение целевого набора данных «time_to_failure».
plt.figure(figsize=(10,5))
plt.title("Time to failure distribution")
ax = sns.kdeplot(train_sample.time_to_failure, label='Train (1% sample)')
Мы видим, что целевая функция находится в диапазоне от 0 до 12 (приблизительно), и большая часть события выглядит так, как будто оно происходит в диапазоне от 0 до 2 (приблизительно).
Анализ временных рядов
Эта проблема основана на времени, поэтому ее важно использовать для проверки распределения акустических и целевых характеристик.
def single_timeseries(final_idx, init_idx=0, step=1, title=””, color1=’orange’, color2=’blue’):
idx = [i for i in range(init_idx, final_idx, step)]
fig, ax1 = plt.subplots(figsize=(10, 5))
fig.suptitle(title, fontsize=14)
ax2 = ax1.twinx()
ax1.set_xlabel(‘index’)
ax1.set_ylabel(‘Acoustic data’)
ax2.set_ylabel(‘Time to failure’)
p1 = sns.lineplot(data=train.iloc[idx].acoustic_data.values, ax=ax1, color=color1)
p2 = sns.lineplot(data=train.iloc[idx].time_to_failure.values, ax=ax2, color=color2)
def double_timeseries(final_idx1, final_idx2, init_idx1=0, init_idx2=0, step=1, title=””):
idx1 = [i for i in range(init_idx1, final_idx1, step)]
idx2 = [i for i in range(init_idx2, final_idx2, step)]
fig, (ax1a, ax2a) = plt.subplots(1,2, figsize=(12,5))
fig.subplots_adjust(wspace=0.4)
ax1b = ax1a.twinx()
ax2b = ax2a.twinx()
ax1a.set_xlabel(‘index’)
ax1a.set_ylabel(‘Acoustic data’)
ax2a.set_ylabel(‘Time to failure’)
p1 = sns.lineplot(data=train.iloc[idx1].acoustic_data.values, ax=ax1a, color=’orange’)
p2 = sns.lineplot(data=train.iloc[idx1].time_to_failure.values, ax=ax1b, color=’blue’)
p3 = sns.lineplot(data=train.iloc[idx2].acoustic_data.values, ax=ax2a, color=’orange’)
p4 = sns.lineplot(data=train.iloc[idx2].time_to_failure.values, ax=ax2b, color=’blue’)
single_timeseries(1000, title=”First thousand rows”)
На приведенном выше графике показаны первые 1000 строк, оранжевые линии – акустические характеристики, а синяя – цель.
мы видим, что цель находится в виде линейной функции,
давайте проверим наличие дополнительных строк для получить предварительный просмотр того, что происходит:
#just using the function written above single_timeseries(10000, title=”Ten thousand rows”
Интересно, давайте проверим все данные nrows= 600k
single_timeseries(6000000, step=10, title=”600k rows”)
Здесь мы смотрим на общие данные, которые мы взяли из строк 629M, мы просто смотрим на 600k, поскольку мы можем видеть, что когда происходит событие, время увеличивается почти до нуля до 12 секунд, один хороший момент следует отметить.
Давайте теперь проверим кумулятивное распределение цели, чтобы проверить, сколько значений на самом деле происходит от 0 до 12 секунд.
pd.set_option(“display.precision”, 4) test1 = pd.read_csv(‘/content/seg_00030f.csv’, dtype=’int16') plt.title(“Acoustic data distribution”) ax = sns.distplot(test1.acoustic_data, label=’seg_37669c’, kde=False)
Интересно, что мы можем видеть, что почти 85% данных, событие происходит в течение минимум 0,3 секунды, что очень близко к 0, еще один момент, который следует отметить.
EDA на тестовых данных
Мы проверили EDA поезда, давайте также проверим исследовательский анализ данных тестов.
Как и в случае с данными Train, давайте также используем CurlWget для тестовых данных соревнований.
!!wget --header="..."
давайте проверим распределение тестовых данных.
pd.set_option(“display.precision”, 4) test1 = pd.read_csv(‘/content/seg_00030f.csv’, dtype=’int16') print(test1.describe()) plt.figure(figsize=(10,5)) plt.title(“Acoustic data distribution”) ax = sns.distplot(test1.acoustic_data, label=’seg_37669c’, kde=False)
Интересны массивные скачки, почти гауссово распределенные данные, и значение также находится в диапазоне от 0 до 12, когда произошло событие.
7. Разработка функций.
Хорошо, это интересный EDA, который мы сделали выше, и у нас был базовый, но продвинутый EDA данных, и мы можем придумать некоторые методы разработки признаков в этой области, аналогичные любой проблеме, основанной на временных рядах.
В связи с этим мы будем рассматривать этот подход как подход First Cut и выполнять моделирование. Мы будем использовать следующее:
- Значит,
- Среднеквадратичное отклонение,
- Мин и Макс строк,
- Абсолютный Макс, Среднее, Стандартное,
- Некоторые квантили от 0,1 до 0,99
- Сворачивающиеся окна
Что такое скользящие окна?
Это метод, в котором мы многократно используем подданные в наборе данных, обычно используемые в анализе временных рядов.
Мы будем использовать эти вспомогательные данные, означающие, минимум, максимум, стандартное значение и квантили.
rows = 150000
segments = int(np.floor(train.shape[0] / rows))
X = pd.DataFrame(index=range(segments), dtype=np.float64)
Y = pd.DataFrame(index=range(segments), dtype=np.float64,columns=['time_to_failure'])
for segment in tqdm(range(segments)):
seg = train.iloc[segment*rows:segment*rows+rows]
x = pd.Series(seg['acoustic_data'].values)
y = seg['time_to_failure'].values[-1]
Y.loc[segment, 'time_to_failure'] = y
X.loc[segment, 'meen'] = x.mean()
X.loc[segment, 'std'] = x.std()
X.loc[segment, 'std'] = x.std()
X.loc[segment, 'min'] = x.min()
X.loc[segment, 'max'] = x.max()
X.loc[segment, 'kurt'] = kurtosis(x)
X.loc[segment, 'skew'] = skew(x)
X.loc[segment, 'abs_max'] = np.abs(x).max()
X.loc[segment, 'abs_mean'] = np.abs(x).mean()
X.loc[segment, 'abs_std'] = np.abs(x).std()
X.loc[segment, 'q_01'] = np.quantile(x,0.01)
X.loc[segment, 'q_05'] = np.quantile(x,0.05)
X.loc[segment, 'q_95'] = np.quantile(x,0.95)
X.loc[segment, 'q_99'] = np.quantile(x,0.99)
#Rolling windows
for windows in [10, 100, 1000]:
x_roll_std = x.rolling(windows).std().dropna().values
X.loc[segment, 'avg_roll_' + str(windows)] = x_roll_std.mean()
X.loc[segment, 'std_roll_' + str(windows)] = x_roll_std.std()
X.loc[segment, 'max_roll_' + str(windows)] = x_roll_std.max()
X.loc[segment, 'min_roll_' + str(windows)] = x_roll_std.min()
X.loc[segment, 'q_01_roll_' + str(windows)] = np.quantile(x_roll_std, 0.01)
X.loc[segment, 'q_05_roll_' + str(windows)] = np.quantile(x_roll_std, 0.05)
X.loc[segment, 'q_95_roll_' + str(windows)] = np.quantile(x_roll_std, 0.95)
X.loc[segment, 'q_99_roll_' + str(windows)] = np.quantile(x_roll_std, 0.99)
когда мы печатаем X.head(), мы получаем
Мы делаем то же самое с тестовыми данными, и, как и в данной структуре, позволяем стандартно масштабировать данные.
from sklearn.preprocessing import StandardScaler scaler = StandardScaler() scaler.fit(X) X_SS= pd.DataFrame(scaler.transform(X), columns=X.columns) Xt_SS= pd.DataFrame(scaler.transform(X_test),columns=X_test.columns)
Хорошо, этот этап разработки признаков завершен, давайте перейдем к моделированию машинного обучения.
8. Моделирование машинного обучения
На данный момент мы масштабировали данные, помогает ускорить расчеты, для этого мы будем использовать 4 модели и проверим, какая из них будет работать хорошо.
Перед моделированием также важно проверить любые значения null или nan.
for i in Xt_SS.columns:
if Xt_SS[i].isnull().any():
print(i)
else:
print(f’There are no NaN values in the data feature: {i}’)
Приведенный выше код напечатает:
Хорошо, вот модели, которые мы будем использовать:
- Регрессор1: XGBRegressor,
- Регрессор2: LightgbmRegressor,
- Regressor3: регрессор опорных векторов и
- Регрессор4: Регрессор CatBoost.
Давайте импортируем все необходимые пакеты для этого моделирования:
#importing packages from sklearn.metrics import mean_absolute_error from sklearn.model_selection import GridSearchCV from sklearn.svm import NuSVR, SVR from sklearn.model_selection import GridSearchCV from sklearn.svm import NuSVR, SVR from sklearn import model_selection, metrics from sklearn.kernel_ridge import KernelRidge import xgboost as xgb import lightgbm as lgb import warnings warnings.filterwarnings(‘ignore’)
Поскольку мы используем много моделей и просто выясняем ошибку Train MAE, я думаю, что лучше написать нашу собственную функцию вместо повторяющегося процесса, который принимает алгоритм, обучает и печатает MAE.
def fit_ml_algo(algo, X_tr, y_tr):
# Fiting the model
model = algo.fit(X_tr, y_tr)
# Cross-validation score metric
yp_train = model.predict(X_tr)
tr_mae = mean_absolute_error(y, yp_train)
return tr_mae, model
XGBRegressor
Процесс для любого алгоритма:
- Мы используем GridSearchCV для поиска различных параметров и,
- затем смоделируйте алгоритм с лучшим параметром, который мы нашли.
#Checking for various parameters
clf = xgb.XGBRegressor(n_jobs=-1)
params = { ‘n_estimators’: [5, 10, 50], ‘max_depth’: [1, 5, 10] }
clf1 = GridSearchCV(clf, params, scoring=’neg_mean_absolute_error’, return_train_score=T rue)
clf1.fit(X_SS, y)
print(clf1.best_params_)
#returns something like: {'max_depth': 1, 'n_estimators': 5}
давайте проверим с лучшим найденным параметром:
#with best parameters found above
tr_mae_xbg, xgb_model= fit_ml_algo(xgb.XGBRegressor(random_state=0, max_depth= clf1.best _estimator_.max_depth, n_estimators= clf1.best_estimator_.n_estimators, booster=’gbtree’ ), X_SS, y)
print(“\n”, f”Train_MAE: {tr_mae_xbg}”)
#returns Train_MAE: 0.9841809641977857
Обратите внимание, что возвращаемые значения могут отличаться от вас во время выполнения.
ЛГБМРегрессор
Процесс тот же, сначала GridSearchCV, а затем лучшие параметры.
#Checking for various parameters
clf2 = lgb.LGBMRegressor(n_jobs=-1)
params = { ‘n_estimators’: [5, 10, 50], ‘max_depth’: [1, 5, 10] }
clf2 = GridSearchCV(clf2, params, scoring=’neg_mean_absolute_error’, return_train_score= True)
clf2.fit(X_SS, y)
print(clf2.best_params_)
#returns: {'max_depth': 1, 'n_estimators': 50}
давайте проверим с лучшим найденным параметром:
#with best parameters found above
tr_mae_lgb, model_lgb = fit_ml_algo(lgb.LGBMRegressor(random_state=0, max_depth= clf2.bes t_estimator_.max_depth, n_estimators= clf2.best_estimator_.n_estimators), X_SS, y)
print(“\n”, f”Train_MAE_LGB: {tr_mae_lgb}”)
#returns: Train_MAE_LGB: 1.1197894705463678
На данный момент похоже, что XGBRegressor лучше, чем LGMBRegressor.
Регрессор опорных векторов
Процесс тот же, сначала GridSearchCV, а затем лучшие параметры.
#Checking for various parameters
clf3 = SVR() params = { ‘gamma’: [0.001, 0.005, 0.01, 0.02, 0.05, 0.1], ‘C’: [0.1, 0.2, 0.25, 0.5, 1, 1.5, 2] }
clf3 = GridSearchCV(clf3, params, scoring=’neg_mean_absolute_error’, return_train_score= True)
clf3.fit(X_SS, y)
print(clf3.best_params_)
#returns: {'C': 1, 'gamma': 0.005}
давайте проверим с лучшим найденным параметром:
#with best parameters found above
tr_mae_svr, model_svr = fit_ml_algo(SVR(C=1, gamma=0.005), X_SS, y, Xt_SS)
print("\n", f"Train_MAE_SVR: {tr_mae_svr}")
#returns: Train_MAE_SVR: 0.9142157963146144
Это интересно, SVR намного лучше, чем другие 2 выше.
Модель Catboost
Модель Catboost — это тип метода повышения градиента, который создает модель прогнозирования в виде ансамбля моделей слабых прогнозов, обычно дерева решений.
Его легко реализовать, он очень мощный и дает хорошие результаты при первом запуске.
Поскольку CatBoost отличается от других алгоритмов повышения и утверждает, что помогает сократить время прогнозирования, поскольку реализует симметричные деревья.
Процедура CatBoost заключается в том, что он вычисляет невязку каждой точки данных, используя модель, которая была обучена на всех других точках данных, т. е. обучает разные модели данных вычислять невязки для каждой точки данных, которые модель никогда не видела.
Затем он обучает модель, используя эти остатки каждой точки данных в качестве метки класса, и, наконец, повторяет n раз.
Подробное объяснение Catboost дано в этом блоге, посмотрите его, если интересно.
Давайте установим Catboost с помощью pip
!pip install catboost from catboost import CatBoostRegressor, Pool
Процесс тот же, сначала GridSearchCV, а затем обучение с лучшими параметрами.
#Checking for various parameters
clf4 = CatBoostRegressor()
params = { ‘depth’: [5, 10, 50], ‘iterations’: [100,500,1000] }
clf4 = GridSearchCV(clf4, params, scoring=’neg_mean_absolute_error’, return_train_score= True)
clf4.fit(X_SS, y, silent=True)
print(clf4.best_params_)
#it will return: {'depth': 10, 'iterations': 1000}
давайте проверим с лучшим найденным параметром:
#with best parameters found above
tr_mae_ct, model_ct = fit_ml_algo(CatBoostRegressor(depth=10, iterations=1000, loss_func tion='MAE', boosting_type='Ordered', silent=True), X_SS, y)
print("\n", f"Train_MAE_Catboost: {tr_mae_ct}")
#returns: Train_MAE_Catboost: 0.6705285866359779
Это хорошо, интересно из всех моделей, что catboost опережает все остальные 3 модели.
Давайте проверим все модели друг друга в виде фрейма данных.
tr_model = pd.DataFrame(
{ ‘Model’: [‘XGBRegressor’, ‘LGBRegression’, ‘SVR’, ‘CatBoost’],
‘MAE’: [ tr_mae_xbg, tr_mae_lgb, tr_mae_svr, tr_mae_ct]})
tr_model.sort_values(by=’MAE’, ascending=True)
Вывод:
Это всего лишь первый подход, и я получил 4,54 личного балла.
Согласно проведенным экспериментам и используемым регрессорам, работа с моделью Catboost будет лучшим вариантом.
Мы работали всего с 600 000 строк, и я думаю, что если мы добавим больше данных, то сможем лучше ранжироваться с моделью, которая считается лучшей.
В качестве примечания, что я попал в 1% лучших, если я правильно помню, я занял 29-е место среди всех 4900 заявок.
Использованная литература:
- https://towardsdatascience.com/supervised-machine-learning-workflow-from-eda-to-api-f6a7719ad897
- https://www.kaggle.com/gargmanish/eda-and-regression
- https://www.kaggle.com/braindeadcoder/understanding-and-preparing-seismic-data
- https://www.kaggle.com/etakla/exploring-the-dataset-bivariate-analysis
- https://github.com/bhattbhavesh91/GA_Sessions/blob/master/ga_dsmp_5jan2019/21_variance_inflation_factor_vif_for_multicolinearity.ipynb
- https://www.kaggle.com/zikazika/useful-new-features-and-a-optimised-model#classic_sta_lta
- https://www.kaggle.com/artgor/even-more-features
Финал конкурса Kaggle
Для следующего шага я добавил гораздо больше функций, разработанных после некоторых исследований, некоторые из них:
- Автокорреляция: серийная корреляция сигнала с задержанной копией самого себя, это сходство между наблюдениями временной задержки между ними, подробнее проверить это.
- Количество пиков: вычисляет количество пиков во временном ряду с разными пиками.
- STA/LTA: Вычисляет стандарт STA/LTA означает краткосрочное среднее значение и долгосрочное среднее значение, как указано в этом документе, очень полезно проверить эти функции.
- Особенности Max to Min: В задаче временных рядов эта функция также помогает нам, поскольку при наличии перка (около максимума или минимума) вариации медленны. Особенности прокатки:
- Прокручиваем характеристики из этого ядра и проверяем разницу между средним, стандартным, квантилями.
Вот снимок публичного и частного счета от kaggle:
Будущая работа
- Разработка функций в моделях машинного обучения требует много времени, и для анализа требуется много экспертов в предметной области,
- Если мы сможем использовать модели глубокого обучения, чтобы попробовать только необработанные данные, это может хорошо сработать с первой попытки.
