Борьба с проектами машинного обучения Обнаружение аномалий данных транзакций

Каталог связанных статей:

1. Линейная регрессия для машинного обучения
2. Логистическая регрессия и реализация машинного обучения на Python
3. Борьба с проектами машинного обучения Обнаружение аномалий данных транзакций
4. Дерево решений для машинного обучения
5. Реализация дерева решений машинного обучения (Decision Tree) на Python
6. PCA (анализ основных компонентов) для машинного обучения
7. разработка функций машинного обучения

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

В первую очередь, конечно, нужно импортировать необходимые библиотеки python

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

%matplotlib inline

Сначала прочитайте исходные данные

data = pd.read_csv("creditcard.csv")
print(data.shape)
data.head() #打印前5行

(284807, 31)

Видно, что всего выборок 284807, и каждая выборка имеет 31 признак, из которых 28 признаков от V1 до V28 - это чистые данные, которые были обработаны и зашифрованы.Хотя я не знаю, что это значит, это может использовать напрямую. Просто используйте его. Остальные несколько функций,

Время указывает время транзакции

Сумма представляет собой общую сумму транзакции

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

Масштабирование функций

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

from sklearn.preprocessing import StandardScaler
# print(data['Amount'].reshape(-1,1))
data['normAmount'] = StandardScaler().fit_transform(data['Amount'].reshape(-1,1))
data = data.drop(['Time','Amount'],axis=1)  #删除不用的列
data.head()

проблема дисбаланса классов

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

count_class = pd.value_counts(data['Class'],sort=True).sort_index()
print(count_class)

0    284315
1       492
Name: Class, dtype: int64

Мы обнаружили, что отрицательных образцов 284 315, а положительных всего 492. Наблюдается серьезный дисбаланс в соотношении положительных и отрицательных образцов, то есть дисбаланс классов. Конкретно следующее.

Дисбаланс классов означает, что при обучении модели классификатора распределение классов в выборке неравномерно, например, в приведенной выше задаче данных 284 807. В идеале количество положительных и отрицательных выборок должно быть примерно равным, а выше положительных образцов 284 315, есть только 492 отрицательных образца, у которых есть серьезная проблема дисбаланса классов.

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

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

1. Понижающая дискретизация: Недостаточная выборка класса с большим количеством выборок в обучающем наборе (класс большинства) и отбрасывание некоторых выборок для устранения дисбаланса классов.
2. Передискретизация: Избыточная выборка класса с небольшим количеством образцов в обучающем наборе (класс меньшинства) и синтез новых образцов для устранения дисбаланса классов. На этот раз будет использоваться очень классический алгоритм передискретизации SMOTE.

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

Сначала отделите функцию X и выходную переменную y.

#分离出特征X 和 输出变量y
X = data.iloc[:,data.columns != 'Class']
y = data.iloc[:,data.columns == 'Class']
# print(X.head())
# print(X.shape)
# print(y.head())
# print(y.shape)

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

В частности, для этой задачи, поскольку имеется только 492 положительных образца, мы случайным образом выбираем 492 отрицательных образца (284 315) в качестве класса большинства, а затем заново составляем новый с предыдущими 492 положительными образцами.

#正样本个数
positive_sample_count = len(data[data.Class == 1])
print("正样本个数为：",positive_sample_count)

#正样本所对应的索引为
positive_sample_index = np.array(data[data.Class == 1].index)
print("正样本在数据集中所对应的索引为（打印前5个）：",positive_sample_index[:5])

#负样本所对应的索引
negative_sample_index = data[data.Class == 0].index
#numpy.random.choice(a, size=None, replace=True, p=None) 从给定的一维阵列生成一个随机样本
#replace 样品是否有更换  True 表示每次都随机生成， false表示只随机生成一次
random_negative_sample_index = np.random.choice(negative_sample_index, positive_sample_count,replace = False)
random_negative_sample_index = np.array(random_negative_sample_index)
print("负样本在数据集中所对应的索引为（打印前5个）：",random_negative_sample_index[:5])

under_sample_index = np.concatenate([positive_sample_index,random_negative_sample_index])
under_sample_data = data.iloc[under_sample_index,:]
X_under_sample = under_sample_data.iloc[:,under_sample_data.columns != 'Class']
y_under_sample = under_sample_data.iloc[:,under_sample_data.columns == 'Class']

print('下采样后，新数据集中，正样本所占比例：',
      len(under_sample_data[under_sample_data.Class==1])/len(under_sample_data))
print('下采样后，新数据集中，负样本所占比例：',
      len(under_sample_data[under_sample_data.Class==0])/len(under_sample_data))
print('下采样后，新数据集的样本个数为：',len(under_sample_data))

正样本个数为： 492
正样本在数据集中所对应的索引为（打印前5个）： [ 541  623 4920 6108 6329]
负样本在数据集中所对应的索引为（打印前5个）： [ 38971   9434  75592 113830 203239]
下采样后，新数据集中，正样本所占比例： 0.5
下采样后，新数据集中，负样本所占比例： 0.5
下采样后，新数据集的样本个数为： 984

Разделение обучающего набора и тестового набора и перекрестная проверка

Далее нам нужно разделить текущий набор данных на обучающий набор и тестовый набор.

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

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

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

Мы можем случайным образом разделить обучающий набор и тестовый набор через train_test_split в модуле sklearn.cross_validation в Sklearn.

Метод вызова: X_train, X_test, y_train, y_test =train_test_split(train_data,train_target,test_size=0.4, random_state=0) Описание параметра:

train_data: образец набора функций, который нужно разделить

train_target: разделенный образец вывода

test_size: если это десятичное число, оно указывает долю выборок в разделенном тестовом наборе, а если это целое число, это количество выборок в тестовом наборе.

random_state: Начальное число случайных чисел на самом деле является номером группы случайных чисел.Когда требуются повторные эксперименты, гарантируется получение одного и того же набора случайных чисел. Например, если вы каждый раз вводите 1, случайный массив, который вы получаете, будет таким же, когда другие параметры одинаковы. А вот заполнять 0 или не заполнять, каждый раз будет по разному.

from sklearn.cross_validation import train_test_split

#这个是将下采样之前的初始样本数据进行训练集和测试集的划分，
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3, random_state=0)

X_train_under_sample, X_test_under_sample, y_train_under_sample, y_test_under_sample = train_test_split(X_under_sample,
                                                                                                        y_under_sample,
                                                                                                        test_size=0.3, 
                                                                                                        random_state=0)
print('训练集样本数：',len(X_train_under_sample)) 
print('测试集样本数：',len(X_test_under_sample)) 

训练集样本数： 688
测试集样本数： 296


C:\Anaconda3\lib\site-packages\sklearn\cross_validation.py:41: DeprecationWarning: This module was deprecated in version 0.18 in favor of the model_selection module into which all the refactored classes and functions are moved. Also note that the interface of the new CV iterators are different from that of this module. This module will be removed in 0.20.
  "This module will be removed in 0.20.", DeprecationWarning)

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

Что касается перекрестной проверки, мы можем справиться с ней с помощью метода KFold в модуле sklearn.cross_validation. Метод вызова:

class sklearn.cross_validation.KFold(n, n_folds=3, shuffle=False, random_state=None)

Описание параметра:

n: количество наборов данных для разделения

n_folds: соответствует количеству кратностей перекрестной проверки

shuffle: перемешивать ли данные перед делением.

Обучение и подбор модели

from sklearn.linear_model import LogisticRegression
from sklearn.cross_validation import KFold, cross_val_score
from sklearn.metrics import confusion_matrix,recall_score,classification_report 

def Kfold_for_TrainModel(X_train_data, y_train_data):
    fold = KFold(len(X_train_data),5,shuffle = False)
    
    # 正则化前面的C 参数
    c_params = [0.01, 0.1, 1, 10, 100]
    #这块生成一个DataFrame 用来保存不同的C参数，对应的召回率是多少
    result_tables = pd.DataFrame(columns = ['C_parameter','Mean recall score'])
    result_tables['C_parameter'] = c_params
    j = 0
    for c_param in c_params:
        print('-------------------------------------------')
        print('C参数为：',c_param)
        print('-------------------------------------------')
        print('')
        
        recall_list = []
        for iteration, indices in enumerate(fold,start=1):
            #采用l1正则化
            lr = LogisticRegression(C=c_param, penalty = 'l1')
            #indices[0] 保存的是这个k=5次训练中的某一次的用来验证的数据的索引
            #indices[1] 保存的是这个k=5次训练中的某一次的用来测试的数据的索引
            lr.fit(X_train_data.iloc[indices[0],:], 
                   y_train_data.iloc[indices[0],:].values.ravel())#.ravel可以将输出降到一维
            #用剩下的一份数据进行测试（即indices[1]中所保存的下标）
            y_undersample_pred = lr.predict(X_train_data.iloc[indices[1],:].values)
            
            recall = recall_score(y_train_data.iloc[indices[1],:].values,
                                  y_undersample_pred)
            recall_list.append(recall)
            print('Iteration ',iteration," 召回率为：",recall)
        print('')
        print('平均召回率为：', np.mean(recall_list))
        print('')
        result_tables.loc[j,'Mean recall score'] = np.mean(recall_list)
        j = j+1
    
#     print(result_tables['Mean recall score'])
    result_tables['Mean recall score'] = result_tables['Mean recall score'].astype('float64')
    best_c_param = result_tables.loc[result_tables['Mean recall score'].idxmax(), 'C_parameter']
    print('*********************************************************************************')
    print('最佳模型对应的C参数 = ', best_c_param)
    print('*********************************************************************************')
    return best_c_param  

best_c_param = Kfold_for_TrainModel(X_train_under_sample, y_train_under_sample)

-------------------------------------------
C参数为： 0.01
-------------------------------------------

Iteration  1  召回率为： 0.9315068493150684
Iteration  2  召回率为： 0.9178082191780822
Iteration  3  召回率为： 1.0
Iteration  4  召回率为： 0.972972972972973
Iteration  5  召回率为： 0.9545454545454546

平均召回率为： 0.9553666992023157

-------------------------------------------
C参数为： 0.1
-------------------------------------------

Iteration  1  召回率为： 0.8356164383561644
Iteration  2  召回率为： 0.863013698630137
Iteration  3  召回率为： 0.9491525423728814
Iteration  4  召回率为： 0.9459459459459459
Iteration  5  召回率为： 0.9090909090909091

平均召回率为： 0.9005639068792076

-------------------------------------------
C参数为： 1
-------------------------------------------

Iteration  1  召回率为： 0.8493150684931506
Iteration  2  召回率为： 0.8904109589041096
Iteration  3  召回率为： 0.9830508474576272
Iteration  4  召回率为： 0.9459459459459459
Iteration  5  召回率为： 0.9090909090909091

平均召回率为： 0.9155627459783485

-------------------------------------------
C参数为： 10
-------------------------------------------

Iteration  1  召回率为： 0.863013698630137
Iteration  2  召回率为： 0.863013698630137
Iteration  3  召回率为： 0.9830508474576272
Iteration  4  召回率为： 0.9459459459459459
Iteration  5  召回率为： 0.8939393939393939

平均召回率为： 0.9097927169206482

-------------------------------------------
C参数为： 100
-------------------------------------------

Iteration  1  召回率为： 0.8767123287671232
Iteration  2  召回率为： 0.863013698630137
Iteration  3  召回率为： 0.9661016949152542
Iteration  4  召回率为： 0.9459459459459459
Iteration  5  召回率为： 0.8939393939393939

平均召回率为： 0.9091426124395708

*********************************************************************************
最佳模型对应的C参数 =  0.01
*********************************************************************************

Когда для параметра регуляризации C установлено значение 0,01, результирующая модель имеет самую высокую полноту. Поэтому мы выбираем регулярность f1, а параметр регулярности равен 0,01 в качестве конечной модели. Далее мы будем использовать окончательную обученную модель, чтобы делать прогнозы на окончательном тестовом наборе. посмотри, как это работает

показатели эффективности

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

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

Поговорим о TP, FP, TN и FN.

TP (Истинно положительный): истинный пример, то есть образец, который на самом деле является положительным примером, правильно оценивается как положительный пример.

FP (ложноположительный): ложноположительный пример, то есть образец, который на самом деле является отрицательным примером, ошибочно оценивается как положительный пример.

TN (True Negtive): истинно отрицательный пример, то есть образец, который на самом деле является отрицательным примером, правильно оценивается как отрицательный пример.

FN (False Negtive): Ложноотрицательный пример, то есть образец, который на самом деле является положительным примером, ошибочно оценивается как отрицательный пример.

Вот некоторые часто используемые показатели производительности

Точность: Доля выборок, которые, по прогнозам, являются положительными примерами, на самом деле является положительной Формула:

Отзыв (также называемый Отзывом): Отношение количества образцов, правильно предсказанных как положительные, ко всем положительным, формула:

Точность: Во всех выборках доля правильных предсказаний формула такова:

Далее нарисуем разреженную матрицу

import itertools
def plot_confusion_matrix(confusion_matrix, classes):
#     print(confusion_matrix)
    #plt.imshow 绘制热图
    plt.figure()
    plt.imshow(confusion_matrix, interpolation='nearest',cmap=plt.cm.Blues)
    plt.title('confusion matrix')
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=0)
    plt.yticks(tick_marks, classes)
    thresh = confusion_matrix.max() / 2.
    for i, j in itertools.product(range(confusion_matrix.shape[0]), range(confusion_matrix.shape[1])):
        plt.text(j, i, confusion_matrix[i, j],
                 horizontalalignment="center",
                 color="white" if confusion_matrix[i, j] > thresh else "black")

    plt.tight_layout()
    plt.ylabel('True label')
    plt.xlabel('Predicted label')
    plt.show()
    print('查准率为：',confusion_matrix[1,1]/(confusion_matrix[1,1]+confusion_matrix[0,1]))
    print('召回率为：',confusion_matrix[1,1]/(confusion_matrix[1,1]+confusion_matrix[1,0]))
    print('准确率为：',(confusion_matrix[0,0]+confusion_matrix[1,1])/(confusion_matrix[0,0]+confusion_matrix[0,1]+confusion_matrix[1,1]+confusion_matrix[1,0]))
    print('*********************************************************************************')

lr = LogisticRegression(C = best_c_param, penalty = 'l1')
lr.fit(X_train_under_sample, y_train_under_sample.values.ravel())

#获得测试集的测试结果
y_undersample_pred = lr.predict(X_test_under_sample.values)
#构建稀疏矩阵
conf_matrix = confusion_matrix(y_test_under_sample,y_undersample_pred)
# np.set_printoptions(precision=2)
class_names = [0,1]

plot_confusion_matrix(conf_matrix
                      , classes=class_names)

查准率为： 0.9019607843137255
召回率为： 0.9387755102040817
准确率为： 0.918918918918919
*********************************************************************************

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

#获得测试集的测试结果
y_pred = lr.predict(X_test.values)
#构建稀疏矩阵
conf_matrix = confusion_matrix(y_test,y_pred)
# np.set_printoptions(precision=2)
class_names = [0,1]

plot_confusion_matrix(conf_matrix
                      , classes=class_names)

查准率为： 0.012054600248182947
召回率为： 0.9251700680272109
准确率为： 0.8694217197429865
*********************************************************************************

Хотя скорость отзыва и уровень точности хорошие, уровень точности слишком низок.То есть, хотя 136 из 147 положительных образцов были предсказаны правильно, цена заключается в том, что 10 894 отрицательных образца предсказываются как положительные образцы одновременно. . . . Я лучше по ошибке убью тысячу, чем отпущу одного.

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

Передискретизация, алгоритм SMOTE

Далее используем передискретизацию, алгоритм SMOTE для обработки данных

Полное название SMOTE — Synthetic Minority Oversampling Technique, который представляет собой синтетический метод передискретизации класса меньшинства Конкретная идея заключается в следующем: анализируйте образцы класса меньшинства и искусственно синтезируйте новые образцы в соответствии с образцами класса меньшинства и добавляйте их в набор данных.

Поток алгоритма выглядит следующим образом:

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

Полное название SMOTE — Synthetic Minority Oversampling Technique, который представляет собой синтетический метод передискретизации класса меньшинства Конкретная идея заключается в следующем: анализируйте образцы класса меньшинства и искусственно синтезируйте новые образцы в соответствии с образцами класса меньшинства и добавляйте их в набор данных.

Поток алгоритма выглядит следующим образом:

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

Ниже посмотрите на конкретный код

#pip install imblearn 需要先安装imblearn包
from imblearn.over_sampling import SMOTE
from sklearn.ensemble import RandomForestClassifier
oversampler = SMOTE(random_state = 0)

X_over_samples, y_over_samples = oversampler.fit_sample(X_train, y_train.values.ravel())

Проверьте, сколько положительных и отрицательных образцов осталось после передискретизации и алгоритма SMOTE.

len(y_over_samples[y_over_samples == 1]), len(y_over_samples[y_over_samples == 0])

(199019, 199019)

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

#这块注意，之前定义的Kfold_for_TrainModel函数传的参数类型是DataFrame，所有这块需要转换下
best_c_param = Kfold_for_TrainModel(pd.DataFrame(X_over_samples), 
                                    pd.DataFrame(y_over_samples))

-------------------------------------------
C参数为： 0.01
-------------------------------------------

Iteration  1  召回率为： 0.9285714285714286
Iteration  2  召回率为： 0.912
Iteration  3  召回率为： 0.9129489124936773
Iteration  4  召回率为： 0.8972829022573392
Iteration  5  召回率为： 0.8974462044795055

平均召回率为： 0.9096498895603901

-------------------------------------------
C参数为： 0.1
-------------------------------------------

Iteration  1  召回率为： 0.9285714285714286
Iteration  2  召回率为： 0.92
Iteration  3  召回率为： 0.9145422357106727
Iteration  4  召回率为： 0.8986521285816574
Iteration  5  召回率为： 0.8987777456756315

平均召回率为： 0.9121087077078782

-------------------------------------------
C参数为： 1
-------------------------------------------

Iteration  1  召回率为： 0.9285714285714286
Iteration  2  召回率为： 0.92
Iteration  3  召回率为： 0.9146686899342438
Iteration  4  召回率为： 0.8987777456756315
Iteration  5  召回率为： 0.8989536096071954

平均召回率为： 0.9121942947576999

-------------------------------------------
C参数为： 10
-------------------------------------------

Iteration  1  召回率为： 0.9285714285714286
Iteration  2  召回率为： 0.92
Iteration  3  召回率为： 0.9146686899342438
Iteration  4  召回率为： 0.8988028690944264
Iteration  5  召回率为： 0.8991294735387592

平均召回率为： 0.9122344922277715

-------------------------------------------
C参数为： 100
-------------------------------------------

Iteration  1  召回率为： 0.9285714285714286
Iteration  2  召回率为： 0.92
Iteration  3  召回率为： 0.9146686899342438
Iteration  4  召回率为： 0.8991169118293617
Iteration  5  召回率为： 0.8989661713165927

平均召回率为： 0.9122646403303254

*********************************************************************************
最佳模型对应的C参数 =  100.0
*********************************************************************************

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

lr = LogisticRegression(C = best_c_param, penalty = 'l1')
lr.fit(X_over_samples, y_over_samples)
# lr.fit(pd.DataFrame(X_over_samples),  pd.DataFrame(y_over_samples).values.ravel())
#获得测试集的测试结果
y_pred = lr.predict(X_test.values)
#构建稀疏矩阵
conf_matrix = confusion_matrix(y_test,y_pred)
# np.set_printoptions(precision=2)
class_names = [0,1]

plot_confusion_matrix(conf_matrix
                      , classes=class_names)

查准率为： 0.06040268456375839
召回率为： 0.9183673469387755
准确率为： 0.9752817667918964
*********************************************************************************

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

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