Раздражение

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

Сегодня утром босс вызвал вас в офис с торжественным выражением лица.

Ты бьешь в барабан в своем сердце, думая, что ты что-то проткнул. К счастью, слова босса быстро вас успокоили.

Он был обеспокоен серьезной потерей клиентов в Европе в последнее время, и многие клиенты ушли к конкурентам, чтобы получить услуги. Начальник спросил, что делать?

Вы выпаливаете: «Хорошо работайте над управлением взаимоотношениями с клиентами!»

Босс смотрит на вас и медленно говорит: «Мы хотим знать, какие клиенты, скорее всего, уйдут в ближайшем будущем».

Да, ловить рыбу там, где есть рыба, — лучшая политика.

Вы понимаете свою миссию — ориентируйтесь на клиентов, которые собираются обработать данные. Эта работа действительно является работой вашего аналитика данных.

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

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

Но как это сделать?

Вы берете данные клиентов в Европе и присматриваетесь.

Клиенты в основном находятся во Франции, Германии и Испании.

Информация в ваших руках, включая их возраст, пол, кредит, данные карты и т. д. Последний столбец (Exited) — это информация о том, был ли клиент потерян.

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

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

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

окрестности

Если рабочий хочет хорошо работать, он должен сначала заточить свои инструменты. Давайте сначала установим и соберем среду.

Первый — установить Python.

Перейдите по этому URL-адресу, чтобы загрузить последнюю версию Anaconda.

Пожалуйста, выберите версию Python 3.6 слева для загрузки и установки.

Второй — создать новую папку с именем demo-customer-churn-ann, скачать данные по этой ссылке и поместить в эту папку.

(Примечание: образцы данных взяты из реального анонимного набора данных, загруженного с официального сайта superdatascience.)

Откройте терминал (или инструмент командной строки), войдите в каталог demo-customer-churn-ann и выполните следующую команду:

jupyter notebook

Браузер отобразит следующий интерфейс:

Нажмите кнопку «Создать» в правом верхнем углу интерфейса, чтобы создать новый блокнот Python 3 с именем «customer-churn-ann».

Подготовка окончена, приступим к очистке данных.

очистить

Во-первых, ознакомьтесь с пакетами pandas и numpy, наиболее часто используемыми для очистки данных.

import numpy as npimport pandas as pd

отcustomer_churn.csvЧтение данных в:

df = pd.read_csv('customer_churn.csv')

Посмотрите, как работает read in:

df.head()

Здесь мы используемhead()Функция для отображения только первых 5 строк.

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

• RowNumber: номер строки, это определенно бесполезно, удалите
  
• CustomerID: ID пользователя, выдается последовательно, удалить
  
• Фамилия: Имя пользователя, не влияет на отток, удалить
  
• CreditScore: кредитный рейтинг, это очень важно, сохраните его
  
• География: Страна/регион, где находится пользователь, имеет влияние, сохраните его.
  
• Пол: пол пользователя, может иметь влияние, зарезервирован
  
• Возраст: возраст оказывает большое влияние, молодые люди чаще меняют банки, сохраняют
  
• Стаж: Сколько лет вы являетесь пользователем этого банка?Это очень важно, держите его
  
• Баланс: Ситуация с депозитом и кредитом, очень важная, зарезервирована
  
• NumOfProducts: используйте количество продуктов, важных, зарезервированных
  
• HasCrCard: Если у вас есть кредитная карта нашего банка, это очень важно, сохраните ее
  
• IsActiveMember: важен ли активный пользователь, сохраните его
  
• EstimatedSalary: расчетный доход, очень важный, зарезервированный
  
• Exited: Независимо от того, был ли он слит, он будет использоваться в качестве данных нашей этикетки.
  

Вышеупомянутый процесс идентификации столбца данных называется «Разработка признаков» и является наиболее часто используемым методом предварительной обработки данных в машинном обучении. Если наш объем данных достаточно велик, а модель машинного обучения достаточно сложна, этот шаг можно пропустить. Но поскольку наших данных всего 10 000, нам также нужно вручную фильтровать функции.

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

X = df.loc[:,['CreditScore', 'Geography', 'Gender', 'Age', 'Tenure', 'Balance', 'NumOfProducts', 'HasCrCard', 'IsActiveMember', 'EstimatedSalary']]

Взгляните на первые несколько строк матрицы признаков:

X.head()

Отображаемые результаты следующие:

Построение матрицы признаков является точным.Далее мы строим целевые данные y, то есть отдает ли пользователь.

y = df.Exited

y.head()

0 11 02 13 04 0Name: Exited, dtype: int64

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

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

X.head()

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

В наборе инструментов Scikit-learn есть специально предусмотренные удобные инструментыLabelEncoder, что позволяет нам легко преобразовывать категориальную информацию в числовые значения.

from sklearn.preprocessing import LabelEncoder, OneHotEncoderlabelencoder1 = LabelEncoder()X.Geography= labelencoder1.fit_transform(X.Geography)labelencoder2 = LabelEncoder()X.Gender = labelencoder2.fit_transform(X.Gender)

Нам нужно преобразовать два столбца, поэтому создаются два разных labelencoder. Функция преобразования называетсяfit_transform.

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

X.head()

Очевидно, что столбцы «География» и «Пол» изменились со строк, которые первоначально описывали категории, на числа.

Будет ли это концом дела? Очевидно, что столбцы «География» и «Пол» изменились со строк, которые первоначально описывали категории, на числа.

Нет, пол можно сказать, есть только два способа получить значение: мужской или женский. Мы можем определить «это мужчина» как 1, а женщина как 0. Два значения описывают только разные категории, и нет никакой двусмысленности.

География другая. Поскольку в наборе данных есть 3 возможных значения страны и региона, они преобразуются в 0 (Франция), 1 (Германия) и 2 (Испания). Вопрос в том, действительно ли существует последовательная (размерная) связь между этими тремя?

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

Для решения этой задачи нам необходимо ввестиOneHotEncoder. Это также класс, предоставляемый Scikit-learn, который может помочь нам преобразовать значение категории в комбинированное представление нескольких переменных.

В нашем наборе данных 3 страны могут быть представлены 3 комбинациями чисел. Например, Франция изменилась с 0 на(1, 0, 0), Германия изменена с 1 на(0, 1, 0), в то время как Испания изменилась с 2 на(0, 0, 1).

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

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

onehotencoder = OneHotEncoder(categorical_features = [1])X = onehotencoder.fit_transform(X).toarray()

На этом этапе наш фрейм данных матрицы признаков преобразуется в массив. Обратите внимание, что все столбцы, преобразованные OneHotEncoder, будут первыми, а затем те, которые останутся без изменений.

Мы смотрим только на первую строку после преобразования:

X[0]

array([ 1.00000000e+00, 0.00000000e+00, 0.00000000e+00, 6.19000000e+02, 0.00000000e+00, 4.20000000e+01, 2.00000000e+00, 0.00000000e+00, 1.00000000e+00, 1.00000000e+00, 1.00000000e+00, 1.01348880e+05])

Таким образом, преобразование, наконец, завершено, верно?

нет.

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

Например, первые два столбца чисел в строке(0, 0), то третий столбец должен быть равен 1. Потому что это определяется правилами преобразования. Только один из трех столбцов может быть 1, а все остальные — 0.

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

Удаляем столбец 0, чтобы не попасть в яму.

X = np.delete(X, [0], 1)

Напечатайте первую строку еще раз:

X[0]

array([ 0.00000000e+00, 0.00000000e+00, 6.19000000e+02, 0.00000000e+00, 4.20000000e+01, 2.00000000e+00, 0.00000000e+00, 1.00000000e+00, 1.00000000e+00, 1.00000000e+00, 1.01348880e+05])

Проверка завершена, и теперь наша обработка матрицы признаков в основном завершена.

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

y.head()

0 11 02 13 04 0Name: Exited, dtype: int64

Это вектор-строка, и нам нужно сначала преобразовать его в вектор-столбец. Вы можете думать об этом как о «вертикальном».

y = y[:, np.newaxis]y

array([[1], [0], [1], ..., [1], [1], [0]])

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

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

onehotencoder = OneHotEncoder()y = onehotencoder.fit_transform(y).toarray()

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

y

array([[ 0., 1.], [ 1., 0.], [ 0., 1.], ..., [ 0., 1.], [ 0., 1.], [ 1., 0.]])

Общие данные готовы. Но мы не можем использовать их все для обучения.

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

Берем 20% данных и откладываем для тестирования. Остальные 8000 единиц данных используются для обучения модели машинного обучения.

from sklearn.model_selection import train_test_splitX_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)

Давайте посмотрим на длину тренировочного набора:

len(X_train)

8000

Посмотрите еще раз на длину тестового набора:

len(X_test)

2000

Подтвержденный.

Не пора ли начать машинное обучение?

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

Мы называем Scikit-learn'sStandardScalerкласс, чтобы завершить этот процесс.

from sklearn.preprocessing import StandardScalersc = StandardScaler()X_train = sc.fit_transform(X_train)X_test = sc.transform(X_test)

Обратите внимание, что мы нормализуем только матрицу признаков, метки нельзя перемещать. Кроме того, обучающий набор и тестовый набор должны быть изменены в соответствии с единым стандартом. Итак, вы видите, на тренировочном наборе мы использовалиfit_transformфункцию, сначала подогнать, а затем преобразовать; на тестовом наборе мы напрямую используем результат подбора обучающего набора и делаем только преобразование.

X_train

array([[-0.5698444 , 1.74309049, 0.16958176, ..., 0.64259497, -1.03227043, 1.10643166], [ 1.75486502, -0.57369368, -2.30455945, ..., 0.64259497, 0.9687384 , -0.74866447], [-0.5698444 , -0.57369368, -1.19119591, ..., 0.64259497, -1.03227043, 1.48533467], ..., [-0.5698444 , -0.57369368, 0.9015152 , ..., 0.64259497, -1.03227043, 1.41231994], [-0.5698444 , 1.74309049, -0.62420521, ..., 0.64259497, 0.9687384 , 0.84432121], [ 1.75486502, -0.57369368, -0.28401079, ..., 0.64259497, -1.03227043, 0.32472465]])

Вы заметите, что многие столбцы имеют гораздо меньшую дисперсию, чем были. Машинное обучение станет удобнее.

Работа по очистке и преобразованию данных завершена.

Древо решений

Если вы читали мою книгу «Ссуда ​​или нет: как использовать Python и машинное обучение, чтобы помочь вам принимать решения?» статья, у вас должно быть ощущение - этот вопрос очень похож на решение об одобрении кредита! Поскольку в этой статье деревья решений очень полезны, почему бы нам не продолжить использовать деревья решений?

Хорошо, давайте проверим, как работает классический алгоритм машинного обучения.

Из Scikit-learn, прочитайте в инструменте дерева решений. Затем установите данные тренировочного набора.

from sklearn import treeclf = tree.DecisionTreeClassifier()clf = clf.fit(X_train, y_train)

Затем используйте модель дерева решений, которую мы построили, чтобы делать прогнозы.

y_pred = clf.predict(X_test)

Распечатать результаты прогноза:

y_pred

array([[ 1., 0.], [ 0., 1.], [ 1., 0.], ..., [ 1., 0.], [ 1., 0.], [ 0., 1.]])

Это ничего не показывает. Давайте позвоним в Scikit-learnclassification_reportмодуль для создания аналитических отчетов.

from sklearn.metrics import classification_reportprint(classification_report(y_test, y_pred))

precision recall f1-score support 0 0.89 0.86 0.87 1595 1 0.51 0.58 0.54 405avg / total 0.81 0.80 0.81 2000

После тестирования дерево решений хорошо зарекомендовало себя в нашем наборе данных. Общая точность составляет 0,81, полнота — 0,80, а показатель f1 — 0,81, что уже является высоким показателем. Он оценивает возможность оттока для 10 клиентов и может правильно оценить 8 раз.

Но достаточно ли этого?

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

Или мы можем использовать глубокое обучение.

глубина

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

Не буду рассказывать кучу математических формул, давайте проведем эксперимент.

Пожалуйста, откройте этот сайт.

Вы увидите игровую площадку для глубокого обучения, как показано ниже:

График справа имеет синие данные внутри и желтые данные во внешнем круге. Ваша задача — использовать модель для классификации двух разных типов данных.

Вы сказали, что это было нелегко? Я увидел это сразу.

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

На картинке вы видите много плюсов и минусов. Давайте поиграем с моделями, манипулируя ими.

Сначала щелкните знак минус слева от «2 СКРЫТЫХ СЛОЯ» в верхней части изображения, чтобы уменьшить количество средних скрытых слоев до 1.

Затем щелкните знак «минус» над «2 нейронами», чтобы уменьшить количество нейронов до 1.

Откройте раскрывающийся список «Функция активации» в верхней части страницы и выберите «Сигмоид».

Текущая модель на самом деле является классической логистической регрессией.

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

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

Потери остаются высокими. Потеря как обучающего набора, так и тестового набора составляет около 0,4, что, очевидно, не соответствует нашим потребностям в классификации.

Попробуем увеличить количество слоев и нейронов. На этот раз щелкните знак «плюс», чтобы добавить количество скрытых слоев обратно к 2, а количество нейронов в обоих слоях равно 2.

Нажмите «Выполнить» еще раз.

Через некоторое время результаты стабилизировались, и вы обнаружили, что на этот раз компьютер использовал две линии, чтобы разрезать самолет на 3 части.

Потери тестового набора упали примерно до 0,25, а потери обучающего набора упали ниже 0,2.

Модель сложнее, и эффект, кажется, лучше.

Чтобы продолжить наши усилия, давайте увеличим количество нейронов в первом скрытом слое до 4.

Жмите бежать, и через несколько мгновений происходит кое-что интересное.

Машина делит плоскость на внутреннюю и внешнюю части почти идеальной кривой. Потери в тестовом наборе и в тренировочном наборе быстро падают, а потери в тренировочном наборе даже близки к 0.

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

Текущий популярный метод деления состоит в том, чтобы использовать количество скрытых слоев, чтобы определить, является ли это «глубиной». Когда количество скрытых слоев в нейронной сети достигает более 3 слоев, это называется «глубокая нейронная сеть» или «глубокое обучение».

Глубокое обучение, которое давно известно, оказывается таким простым.

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

Рамка

Движком игровой площадки является фреймворк глубокого обучения Tensorflow от Google.

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

Существует множество фреймворков глубокого обучения, поддерживающих язык Python, помимо Tensorflow есть PyTorch, Theano и MXNet и т. д.

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

Я предпочитаю Тензорфлоу. Но сам Tensorflow — низкоуровневая библиотека. Хотя со сменой версии интерфейс становится все более удобным в использовании. Но для новичков многие детали все еще слишком тривиальны, чтобы их понять.

У новичков ограниченное терпение, и легко сдаться, если неудач слишком много.

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

Эти фреймворки включают Keras, TensorLayer и т. д. Тот, который мы собираемся использовать сегодня, называется TFlearn.

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

настоящий бой

Хватит говорить, давайте продолжим писать код.

Прежде чем писать код, вернитесь в терминал и выполните следующие команды, чтобы установить несколько пакетов:

pip install tensorflowpip install tflearn

После выполнения вернитесь в Блокнот.

Мы называем tflearn framework.

import tflearn

Затем мы начали строить блоки, создавая слои нейронной сети.

Первый — входной слой.

net = tflearn.input_data(shape=[None, 11])

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

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

Далее мы создаем скрытый слой. Здесь мы собираемся использовать глубокое обучение для создания 3 слоев.

net = tflearn.fully_connected(net, 6, activation='relu')net = tflearn.fully_connected(net, 6, activation='relu')net = tflearn.fully_connected(net, 6, activation='relu')

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

Функция Relu является разновидностью функции активации. Похоже на это.

Если вы хотите узнать больше о функциях активации, обратитесь к разделу «Обучающие ресурсы» ниже.

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

После настройки 3 промежуточных скрытых слоев давайте создадим выходной слой.

net = tflearn.fully_connected(net, 2, activation='softmax')net = tflearn.regression(net)

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

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

model = tflearn.DNN(net)

Имея модель в руках, мы можем использовать функцию подгонки. Как вы думаете, это очень похоже на использование Scikit-learn?

model.fit(X_train, y_train, n_epoch=30, batch_size=32, show_metric=True)

Обратите внимание, что здесь есть еще несколько параметров, поясним.

n_epoch: Обучение данным за несколько эпох.
batch_size: количество строк данных, вводимых в модель каждый раз.
show_metric: распечатывать ли результаты во время тренировки.


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

Training Step: 7499 | total loss: [1m[32m0.39757[0m[0m | time: 0.656s| Adam | epoch: 030 | loss: 0.39757 - acc: 0.8493 -- iter: 7968/8000Training Step: 7500 | total loss: [1m[32m0.40385[0m[0m | time: 0.659s| Adam | epoch: 030 | loss: 0.40385 - acc: 0.8487 -- iter: 8000/8000--

Мы видим, что потери на тренировочном наборе составляют около 0,4.

Открываем терминал, входим

tensorboard --logdir=/tmp/tflearn_logs/

Затем введите в браузереhttp://localhost:6006/

Вы можете увидеть следующий интерфейс:

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

Открываем вкладку GRAPHS, мы можем просмотреть график структуры нейронной сети.

Процесс сборки строительных блоков можно увидеть здесь.

оценивать

Теперь, когда модель обучена, попробуем сделать прогноз.

Посмотрите на первую строку матрицы признаков для тестового набора.

X_test[0]

array([ 1.75486502, -0.57369368, -0.55204276, -1.09168714, -0.36890377, 1.04473698, 0.8793029 , -0.92159124, 0.64259497, 0.9687384 , 1.61085707])

Давайте используем его для прогнозирования результатов классификации.

y_pred = model.predict(X_test)

Распечатайте и посмотрите:

y_pred[0]

array([ 0.70956731, 0.29043278], dtype=float32)

Согласно модели, вероятность того, что клиент не уйдет, составляет 0,70956731.

Давайте посмотрим на фактические данные этикетки:

y_test[0]

array([ 1., 0.])

Клиент не сдулся. Это предсказание верно.

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

score = model.evaluate(X_test, y_test)print('Test accuarcy: %0.4f%%' % (score[0] * 100))

Test accuarcy: 84.1500%

На тестовом наборе точность достигла 84,15%, что очень хорошо!

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

иллюстрировать

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

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

Во-вторых, в некоторых областях улучшение на 1% означает миллионы долларов прибыли или тысячи спасенных жизней.

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

Оригинальное время выпуска: 2017-11-27

Автор этой статьи: Ван Шуи

Эта статья от партнеров сообщества Yunqi.Круговая диаграмма данных THU", для получения соответствующей информации вы можете следить"Круговая диаграмма данных THU"Официальный аккаунт WeChat