ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ

ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ Edu.Vsu.Ru
Автор На чтение 3034 мин Опубликовано

Полезные ресурсы

  • Open Machine Learning Course. Topic 3. Classification, Decision Trees and k Nearest Neighbors
    (перевод этой статьи на английский)
  • Видеозапись
    лекции по мотивам этой статьи
  • Реализация многих алгоритмов машинного обучения с нуля – репозиторий
    rushter
    . Полезно, например, посмотреть, как реализованы деревья решений и метод ближайших соседей;
  • Курс
    Евгения Соколова по машинному обучению (материалы на GitHub). Хорошая теория, нужна неплохая математическая подготовка;
  • Курс
    Дмитрия Ефимова на GitHub (англ.). Тоже очень качественные материалы;
  • Статья
    «Энтропия и деревья принятия решений» на Хабре;
  • Статья
    «Машинное обучение и анализ данных. Лекция для Малого ШАДа Яндекса» на Хабре.

Полезные источники

Статья написана в соавторстве с yorko
(Юрием Кашницким). Материал статьи доступен в виде тетрадки
Jupyter в GitHub-репозитории
курса.

Полезные источники

Статья написана в соавторстве с yorko
(Юрием Кашницким). Материал статьи доступен в виде тетрадки
Jupyter в GitHub-репозитории
курса.

Полезные ресурсы

Материал статьи доступен в GitHub-репозитории
курса

в виде тетрадок
Jupyter.

План этой статьи

Домашние задания в курсе

Каждая статья сопровождается домашним заданием в виде Jupyter Notebook
, в который надо дописать код, и на основе этого выбрать правильный ответ в Google-форме. Примеры домашних заданий приведены в статьях серии (в конце).

Линейная регрессия vs XGBoost

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

Построение линейной регрессии 

   from sklearn.linear_model import LinearRegression

X_train, X_test, y_train, y_test = prepareData(dataset.Users, test_size=0.3, lag_start=12, lag_end=48)
lr = LinearRegression()
lr.fit(X_train, y_train)
prediction = lr.predict(X_test)
plt.figure(figsize=(15, 7))
plt.plot(prediction, "r", label="prediction")
plt.plot(y_test.values, label="actual")
plt.legend(loc="best")
plt.title("Linear regression\n Mean absolute error {} users".format(round(mean_absolute_error(prediction, y_test))))
plt.grid(True);

ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ

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

Также можно провести оценку модели на кросс-валидации, тому же принципу, что был использован ранее. Для этого воспользуемся функцией (с небольшими модификациями), предложенной в посте Pythonic Cross Validation on Time Series

Код для кросс-валидации 

   def performTimeSeriesCV(X_train, y_train, number_folds, model, metrics):
    print('Size train set: {}'.format(X_train.shape))

    k = int(np.floor(float(X_train.shape[0]) / number_folds))
    print('Size of each fold: {}'.format(k))

    errors = np.zeros(number_folds-1)

    # loop from the first 2 folds to the total number of folds    
    for i in range(2, number_folds + 1):
        print('')
        split = float(i-1)/i
        print('Splitting the first ' + str(i) + ' chunks at ' + str(i-1) + '/' + str(i) )

        X = X_train[:(k*i)]
        y = y_train[:(k*i)]
        print('Size of train + test: {}'.format(X.shape)) # the size of the dataframe is going to be k*i

        index = int(np.floor(X.shape[0] * split))

        # folds used to train the model        
        X_trainFolds = X[:index]        
        y_trainFolds = y[:index]

        # fold used to test the model
        X_testFold = X[(index + 1):]
        y_testFold = y[(index + 1):]

        model.fit(X_trainFolds, y_trainFolds)
        errors[i-2] = metrics(model.predict(X_testFold), y_testFold)

    # the function returns the mean of the errors on the n-1 folds    
    return errors.mean()  
  

   %%time
performTimeSeriesCV(X_train, y_train, 5, lr, mean_absolute_error)  
  

   Size train set: (1838, 39)
Size of each fold: 367

Splitting the first 2 chunks at 1/2
Size of train + test: (734, 39)

Splitting the first 3 chunks at 2/3
Size of train + test: (1101, 39)

Splitting the first 4 chunks at 3/4
Size of train + test: (1468, 39)

Splitting the first 5 chunks at 4/5
Size of train + test: (1835, 39)
CPU times: user 59.5 ms, sys: 7.02 ms, total: 66.5 ms
Wall time: 18.9 ms

Out: 4613.17893150896

На 5 фолдах получили среднюю абсолютную ошибку в 4.6 K пользователей, достаточно близко к оценке качества, полученной на тестовом датасете.

ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ

Код для построения прогноза с XGBoost 

   import xgboost as xgb

def XGB_forecast(data, lag_start=5, lag_end=20, test_size=0.15, scale=1.96):

    # исходные данные
    X_train, X_test, y_train, y_test = prepareData(dataset.Users, lag_start, lag_end, test_size)
    dtrain = xgb.DMatrix(X_train, label=y_train)
    dtest = xgb.DMatrix(X_test)

    # задаём параметры
    params = {
        'objective': 'reg:linear',
        'booster':'gblinear'
    }
    trees = 1000

    # прогоняем на кросс-валидации с метрикой rmse
    cv = xgb.cv(params, dtrain, metrics = ('rmse'), verbose_eval=False, nfold=10, show_stdv=False, num_boost_round=trees)

    # обучаем xgboost с оптимальным числом деревьев, подобранным на кросс-валидации
    bst = xgb.train(params, dtrain, num_boost_round=cv['test-rmse-mean'].argmin())

    # можно построить кривые валидации
    #cv.plot(y=['test-mae-mean', 'train-mae-mean'])

    # запоминаем ошибку на кросс-валидации
    deviation = cv.loc[cv['test-rmse-mean'].argmin()]["test-rmse-mean"]

    # посмотрим, как модель вела себя на тренировочном отрезке ряда
    prediction_train = bst.predict(dtrain)
    plt.figure(figsize=(15, 5))
    plt.plot(prediction_train)
    plt.plot(y_train)
    plt.axis('tight')
    plt.grid(True)

    # и на тестовом
    prediction_test = bst.predict(dtest)
    lower = prediction_test-scale*deviation
    upper = prediction_test+scale*deviation

    Anomalies = np.array([np.NaN]*len(y_test))
    Anomalies[y_test<lower] = y_test[y_test<lower]

    plt.figure(figsize=(15, 5))
    plt.plot(prediction_test, label="prediction")
    plt.plot(lower, "r--", label="upper bond / lower bond")
    plt.plot(upper, "r--")
    plt.plot(list(y_test), label="y_test")
    plt.plot(Anomalies, "ro", markersize=10)
    plt.legend(loc="best")
    plt.axis('tight')
    plt.title("XGBoost Mean absolute error {} users".format(round(mean_absolute_error(prediction_test, y_test))))
    plt.grid(True)
    plt.legend()  
  

   XGB_forecast(dataset, test_size=0.2, lag_start=5, lag_end=30)

ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ


ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ

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

Plotly

Мы рассмотрели визуализации на базе библиотеки matplotlib
. Однако это не единственная опция для построения графиков на языке python
. Познакомимся также с библиотекой plotly

. Plotly
— это open-source библиотека, которая позволяет строить интерактивные графики в jupyter.notebook’e без необходимости зарываться в javascript код.

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

Перед началом работы импортируем все необходимые модули и инициализируем plotly
с помощью команды init_notebook_mode
.

   from plotly.offline import download_plotlyjs, init_notebook_mode, plot, iplot
import plotly
import plotly.graph_objs as go

init_notebook_mode(connected=True)

Для начала построим line plot

с динамикой числа вышедших игр и их продаж по годам.

   # посчитаем число вышедших игр и проданных копий по годам
years_df = df.groupby('Year_of_Release')[['Global_Sales']].sum().join(
    df.groupby('Year_of_Release')[['Name']].count()
)
years_df.columns = ['Global_Sales', 'Number_of_Games']

# создаем линию для числа проданных копий
trace0 = go.Scatter(
    x=years_df.index,
    y=years_df.Global_Sales,
    name='Global Sales'
)

# создаем линию для числа вышедших игр 
trace1 = go.Scatter(
    x=years_df.index,
    y=years_df.Number_of_Games,
    name='Number of games released'
)

# определяем массив данных и задаем title графика в layout
data = [trace0, trace1]
layout = {'title': 'Statistics of video games'}

# cоздаем объект Figure и визуализируем его
fig = go.Figure(data=data, layout=layout)
iplot(fig, show_link=False)

В plotly
строится визуализация объекта Figure
, который состоит из данных (массив линий, которые в библиотеке называются traces
) и оформления/стиля, за который отвечает объект layout
. В простых случаях можно вызывать функцию iplot
и просто от массива traces
.

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

img

Можно сразу сохранить график в виде html-файла.

   plotly.offline.plot(fig, filename='years_stats.html', show_link=False)

Посмотрим также на рыночную долю игровых платформ, рассчитанную по количеству выпущенных игр и по суммарной выручке. Для этого построим bar chart

.

   # считаем число проданных и вышедших игр по платформам
platforms_df = df.groupby('Platform')[['Global_Sales']].sum().join(
    df.groupby('Platform')[['Name']].count()
)
platforms_df.columns = ['Global_Sales', 'Number_of_Games']
platforms_df.sort_values('Global_Sales', ascending=False, inplace=True)

# создаем traces для визуализации
trace0 = go.Bar(
    x=platforms_df.index,
    y=platforms_df.Global_Sales,
    name='Global Sales'
)

trace1 = go.Bar(
    x=platforms_df.index,
    y=platforms_df.Number_of_Games,
    name='Number of games released'
)

# создаем массив с данными и задаем title для графика и оси x в layout
data = [trace0, trace1]
layout = {'title': 'Share of platforms', 'xaxis': {'title': 'platform'}}

# создаем объект Figure и визуализируем его
fig = go.Figure(data=data, layout=layout)
iplot(fig, show_link=False)

img

В plotly
можно построить и box plot

. Рассмотрим распределения оценок критиков в зависимости от жанра игры.

   
# создаем Box trace для каждого жанра из наших данных
data = []
for genre in df.Genre.unique():
    data.append(
        go.Box(y=df[df.Genre==genre].Critic_Score, name=genre)
    )

# визуализируем данные
iplot(data, show_link = False)

img

С помощью plotly
можно построить и другие типы визуализаций. Графики получаются достаточно симпатичными с дефолтными настройками. Однако библиотека позволяет и гибко настраивать различные параметры визуализации: цвета, шрифты, подписи, аннотации и многое другое.

Полезные источники

Простой подсчет слов

Составим словарь всех слов с помощью CountVectorizer. Всего в выборке 74849 уникальных слов. Если посмотреть на примеры полученных «слов» (лучше их называть токенами), то можно увидеть, что многие важные этапы обработки текста мы тут пропустили (автоматическая обработка текстов – это могло бы быть темой отдельной серии статей).

   cv = CountVectorizer()
cv.fit(text_train)

print(len(cv.vocabulary_)) #74849  
  

   print(cv.get_feature_names()[:50])
print(cv.get_feature_names()[50000:50050])

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

   X_train = cv.transform(text_train)
X_test = cv.transform(text_test)

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

   %%time
logit = LogisticRegression(n_jobs=-1, random_state=7)
logit.fit(X_train, y_train)
print(round(logit.score(X_train, y_train), 3), round(logit.score(X_test, y_test), 3))

Коэффициенты модели можно красиво отобразить.

Код визуализации коэффициентов модели 

   def visualize_coefficients(classifier, feature_names, n_top_features=25):
# get coefficients with large absolute values 
coef = classifier.coef_.ravel()
positive_coefficients = np.argsort(coef)[-n_top_features:]
negative_coefficients = np.argsort(coef)[:n_top_features]
interesting_coefficients = np.hstack([negative_coefficients, positive_coefficients])
# plot them
plt.figure(figsize=(15, 5))
colors = ["red" if c < 0 else "blue" for c in coef[interesting_coefficients]]
plt.bar(np.arange(2 * n_top_features), coef[interesting_coefficients], color=colors)
feature_names = np.array(feature_names)
plt.xticks(np.arange(1, 1 + 2 * n_top_features), feature_names[interesting_coefficients], rotation=60, ha="right");
  
  

   def plot_grid_scores(grid, param_name):
plt.plot(grid.param_grid[param_name], grid.cv_results_['mean_train_score'],
color='green', label='train')
plt.plot(grid.param_grid[param_name], grid.cv_results_['mean_test_score'],
color='red', label='test')
plt.legend();
  
  

   visualize_coefficients(logit, cv.get_feature_names())

ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ

Подберем коэффициент регуляризации для логистической регрессии. Используем sklearn.pipeline, поскольку CountVectorizer правильно применять только на тех данных, на которых в текущий момент обучается модель (чтоб не «подсматривать» в тестовую выборку и не считать по ней частоты вхождения слов). В данном случае pipeline задает последовательность действий: применить CountVectorizer, затем обучить логистическую регрессию. Так мы поднимаем долю правильных ответов до 88.5% на кросс-валидации и 87.9% – на отложенной выборке.

   from sklearn.pipeline import make_pipeline

text_pipe_logit = make_pipeline(CountVectorizer(), 
LogisticRegression(n_jobs=-1, random_state=7))

text_pipe_logit.fit(text_train, y_train)
print(text_pipe_logit.score(text_test, y_test))

from sklearn.model_selection import GridSearchCV

param_grid_logit = {'logisticregression__C': np.logspace(-5, 0, 6)}
grid_logit = GridSearchCV(text_pipe_logit, param_grid_logit, cv=3, n_jobs=-1)

grid_logit.fit(text_train, y_train)
grid_logit.best_params_, grid_logit.best_score_
plot_grid_scores(grid_logit, 'logisticregression__C')
grid_logit.score(text_test, y_test)

ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ

Теперь то же самое, но со случайным лесом. Видим, что с логистической регрессией мы достигаем большей доли правильных ответов меньшими усилиями. Лес работает дольше, на отложенной выборке 85.5% правильных ответов.

Код для обучения случайного леса 

   from sklearn.ensemble import RandomForestClassifier
forest = RandomForestClassifier(n_estimators=200, n_jobs=-1, random_state=17)
forest.fit(X_train, y_train)
print(round(forest.score(X_test, y_test), 3))

XOR-проблема

Теперь рассмотрим пример, где линейные модели справляются хуже.

Линейные методы классификации строят все же очень простую разделяющую поверхность – гиперплоскость. Самый известный игрушечный пример, в котором классы нельзя без ошибок поделить гиперплоскостью (то есть прямой, если это 2D), получил имя «the XOR problem».

XOR – это «исключающее ИЛИ», булева функция со следующей таблицей истинности:

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

Код, рисующий следующие 3 картинки 

 # порождаем данные
rng = np.random.RandomState(0)
X = rng.randn(200, 2)
y = np.logical_xor(X[:, 0] > 0, X[:, 1] > 0)
  

 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired);
  

 defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'
 def plot_boundary(clf, X, y, plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# plot the decision function for each datapoint on the grid
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
Z = Z.reshape(xx.shape)

image = plt.imshow(Z, interpolation='nearest',
extent=(xx.min(), xx.max(), yy.min(), yy.max()),
aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
linetypes='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'def plot_boundary(clf, X, y, plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# plot the decision function for each datapoint on the grid
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
Z = Z.reshape(xx.shape)

image = plt.imshow(Z, interpolation='nearest',
extent=(xx.min(), xx.max(), yy.min(), yy.max()),
aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
linetypes='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'(def plot_boundary(clf, X, y, plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# plot the decision function for each datapoint on the grid
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
Z = Z.reshape(xx.shape)

image = plt.imshow(Z, interpolation='nearest',
extent=(xx.min(), xx.max(), yy.min(), yy.max()),
aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
linetypes='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline6lt;/math -->)lt;!-- math>$inline$x_1$inline(6)lt;/math -->lt;!-- math>$inline$x_1$inline(6)lt;/math -->

lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->lt;!-- math>$inline$x_1$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!-- math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;!— math>$inline$x_1$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;!— math>$inline$x_1$inline(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;/math -->lt;!-- math>$inline$x_1$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;/math —>lt;!— math>$inline$x_1$inline(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;!— math>$inline$x_2$inline(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->lt;!-- math>$inline$x_1$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;!— math>$inline$x_2$inline(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;/math -->lt;!-- math>$inline$x_1$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;/math —>lt;!— math>$inline$x_1$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;/math —>lt;!— math>$inline$x_1$inline(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;!— math>$inline$x_2$inline(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_1$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;!— math>$inline$x_1$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;!— math>$inline$x_1$inline(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;!— math>$inline$x_2$inline(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;!— math>$inline$x_2$inline(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;!— math>$inline$x_2$inline(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’
6lt;!— math>$inline$x_2$inline
6lt;/math —>)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;!— math>$inline$x_2$inline(
6)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);)lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r’def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(def plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'
6lt;!-- math>$inline$x_1$inline
6lt;/math -->)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!-- math>$inline$x_2$inline(
6)lt;/math -->lt;!-- math>$inline$x_2$inline(
6)lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;!— math>$inline$x_2$inlinedef plot_boundary(clf, X, y, plot_title):
 xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
 np.linspace(-3, 3, 50))
 clf.fit(X, y)
 # plot the decision function for each datapoint on the grid
 Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())).T)[:, 1]
 Z = Z.reshape(xx.shape)
image = plt.imshow(Z, interpolation='nearest',
 extent=(xx.min(), xx.max(), yy.min(), yy.max()),
 aspect='auto', origin='lower', cmap=plt.cm.PuOr_r)
 contours = plt.contour(xx, yy, Z, levels=[0], linewidths=2,
 linetypes='--')
 plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm.Paired)
 plt.xticks(())
 plt.yticks(())
 plt.xlabel(r'(
6)lt;!-- math>$inline$x_1$inline(
6)lt;/math -->lt;/math -->
 lt;!-- math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math -->
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.ylabel(r'(
6)lt;!— math>$inline$x_2$inline(
6)lt;/math —>lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регрессию будем обучать стохастическим градиентным спуском. Пока это понятно, что так быстрее, но далее в программе у нас отдельная статья об этом деле. Построим валидационные кривые, показывающие, как качество (ROC AUC) на обучающей и проверочной выборке меняется с изменением нормы регулирования.)
 plt.axis([-3, 3, -3, 3])
 plt.colorbar(image)
 plt.title(plot_title, fontsize=12);lt;/math —>
 lt;!— math>$inline$x_1$inline
defplot_boundary(clf, X, y,plot_title):
xx, yy = np.meshgrid(np.linspace(-3, 3, 50),
np.linspace(-3, 3, 50))
clf.fit(X, y)
# построим функцию решения для каждой точки данных в сетке
Z = clf.predict_proba(np.vstack((xx.ravel(), yy.ravel())). T)[:, 1]
Z = Z.reshape(xx.shape)

изображение = plt.imshow(Z, интерполяция = 'ближайший',
экстент=(xx.min(), xx.max(), yy.min(), yy.max()),
аспект = 'авто', происхождение = 'нижний', cmap = plt.cm. ПуОр_р)
контуры = plt.contour(xx, yy, Z, level=[0], linewidths=2,
типы линий='--')
plt.scatter(X[:, 0], X[:, 1], s=30, c=y, cmap=plt.cm. В паре)
plt.xticks(())
plt.yticks(())
plt.xlabel(r'$$')
plt.ylabel(r'$$')
plt.axis([-3, 3, -3, 3])
plt.colorbar(изображение)
plt.title(plot_title, fontsize=12);
lt;/math —>
 plot_boundary(LogisticRegression(), X, y,
"Logistic Regression, XOR problem")
  
 from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
  
 logit_pipe = Pipeline([('poly', PolynomialFeatures(degree=2)), 
('logit', LogisticRegression())])
  
 plot_boundary(logit_pipe, X, y,
"Logistic Regression + quadratic features. XOR problem")
  
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Очевидно, нельзя провести так, чтобы без ошибок отделить один класс от другого. Поэтому логистическая регрессия плохо справляется с такой отраслью.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 А вот если на входе подать полиномиальные признаки, в данном случае до 2 степени, то проблема решается.
 ОТКРЫТЫЙ КУРС МАШИННОГО ОБУЧЕНИЯ ВРЕМЕННЫЕ РЯДЫ
 Здесь логистическая регрессия все равно построила гиперплоскость, но в 6-мерном пространстве границ $1, x_1, x_2, x_1^2, x_1x_2$
 и $x_2^2$
 . В проекции на исходное пространство признаки $x_1, x_2$
 граница получилась нелинейной.
 На примере полиномиальных признаков действительно можно, но построить их явно – вычислительно неэффективно. Гораздо быстрее работает SVM с ядровым трюком. При таком подходе в пространстве высокой размерности считается только расстояние между объектами (задаваемое умеренное число), и явно плодить комбинаторно большое число критериев не приходится. Про это подробно можно почитать в  курсе 
 Евгения Соколова (математика уже серьезная).
 5. Кривые валидации и обучения
 Мы уже получили представление о боковой модели, кросс-валидации и регуляризации.
Теперь рассмотрим главный вопрос:
 Если качественные модели нас не устраивают, что делать?
  •  Сделать модель сложнее или проще?
  •  Добавить больше признаков?
  •  Или нам просто нужно больше данных для обучения?
 Ответы на данные вопросы не всегда остаются на поверхности. В частности, иногда использование более сложных моделей приводит к ухудшению показателей. Либо добавление результатов не привело к ощутимым изменениям. Способность принять правильное решение и выбрать правильный способ улучшения модели, собственно говоря, и отличает хорошего специалиста от плохого.
 Будем работать с известными данными по оттоку клиентов телеком-оператора.
  Импорт библиотек и чтение данных 
 from __future__ import division, print_function
# отключим всякие предупреждения Anaconda
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
from matplotlib import pyplot as plt
import seaborn as sns

import numpy as np
import pandas as pd
from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV, SGDClassifier
from sklearn.model_selection import validation_curve

data = pd.read_csv('../../data/telecom_churn.csv').drop('State', axis=1)
data['International plan'] = data['International plan'].map({'Yes': 1, 'No': 0})
data['Voice mail plan'] = data['Voice mail plan'].map({'Yes': 1, 'No': 0})

y = data['Churn'].astype('int').values
X = data.drop('Churn', axis=1).values
  
 Логистическую регресс