keras-CNN实现恶意URL请求检测

谁践踏了优雅 2024-02-19 13:31 80阅读 0赞

#### 导入所需要的库 ####

#### 读取文件 ####

x_train = pd.read_csv(train_data_path,header=None)
    y_train = pd.read_csv(train_label_path,header=None)
    x_test = pd.read_csv(test_data_path,header=None)
    y_test = pd.read_csv(test_label_path,header=None)

train_index = list(y_train[y_train[0]==1].index)

import numpy as np

y_train_label = np.ones(6000)
    for i,value in enumerate(y_train_label):
        if i in train_index:
            y_train_label[i] = 0
    y_train_label

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

test_index = list(y_test[y_train[0]==1].index)

y_test_label = np.ones(6000)
    for i,value in enumerate(y_test_label):
        if i in test_index:
            y_test_label[i] = 0
    y_test_label

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

# 使用Sequential模型
    from keras.models import Sequential

# 导入Dense，Dropout，Flatten，Conv2D，MaxPooling2D层
    from keras.layers import Dense, Dropout, Flatten
    from keras.layers import Conv2D, MaxPooling2D

# batch大小，每处理60个样本进行一次梯度更新
    batch_size = 60

# 类别数
    num_classes = 2

# 迭代次数
    epochs = 30

# input image dimensions
    # 150x150 图像
    img_rows, img_cols = 150,150

x_train = np.array(x_train)
    x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1) 
    x_train.shape

(6000, 150, 150, 1)

x_test = np.array(x_test)
    x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1) 
    x_test.shape

(6000, 150, 150, 1)

input_shape = (img_rows, img_cols, 1)
    input_shape

(150, 150, 1)

# 数据转为float32型
    x_train = x_train.astype('float32')
    x_test = x_test.astype('float32')

import keras

# 标签转换为独热码
    y_train = keras.utils.to_categorical(y_train_label, num_classes)
    y_test = keras.utils.to_categorical(y_test_label, num_classes)

y_train

array([[0., 1.],
           [0., 1.],
           [0., 1.],
           ...,
           [0., 1.],
           [0., 1.],
           [0., 1.]], dtype=float32)

# 构建模型
    model = Sequential()

model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))

# model.add(keras.layers.normalization.BatchNormalization(epsilon=1e-6, weights=None))

from keras.layers.normalization import BatchNormalization

model.add(BatchNormalization(axis=1))

# 加最大值池化
    model.add(MaxPooling2D(pool_size=(2, 2)))

# 再加一层卷积，64个卷积核
    model.add(Conv2D(64, (3, 3), activation='relu'))

model.add(BatchNormalization(axis=1))

# 加最大值池化
    model.add(MaxPooling2D(pool_size=(3, 3)))

# 加Dropout，断开神经元比例为25%
    model.add(Dropout(0.25))

# 加Flatten，数据一维化
    model.add(Flatten())

# 加Dense，输出128维
    model.add(Dense(128, activation='relu'))

# 再一次Dropout
    model.add(Dropout(0.5))

# 最后一层为Softmax，输出为2个分类的概率
    model.add(Dense(num_classes, activation='softmax'))

# 配置模型，损失函数采用交叉熵，优化采用Adadelta，将识别准确率作为模型评估 
    model.compile(loss=keras.losses.categorical_crossentropy, 
                  optimizer=keras.optimizers.Adadelta(), 
                  metrics=['accuracy'])

model.summary()

_________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    conv2d_3 (Conv2D)            (None, 148, 148, 32)      320       
    _________________________________________________________________
    batch_normalization_4 (Batch (None, 148, 148, 32)      592       
    _________________________________________________________________
    max_pooling2d_8 (MaxPooling2 (None, 74, 74, 32)        0         
    _________________________________________________________________
    conv2d_4 (Conv2D)            (None, 72, 72, 64)        18496     
    _________________________________________________________________
    batch_normalization_5 (Batch (None, 72, 72, 64)        288       
    _________________________________________________________________
    max_pooling2d_9 (MaxPooling2 (None, 36, 36, 64)        0         
    _________________________________________________________________
    conv2d_5 (Conv2D)            (None, 34, 34, 64)        36928     
    _________________________________________________________________
    batch_normalization_6 (Batch (None, 34, 34, 64)        136       
    _________________________________________________________________
    max_pooling2d_10 (MaxPooling (None, 11, 11, 64)        0         
    _________________________________________________________________
    dropout_3 (Dropout)          (None, 11, 11, 64)        0         
    _________________________________________________________________
    flatten_2 (Flatten)          (None, 7744)              0         
    _________________________________________________________________
    dense_3 (Dense)              (None, 128)               991360    
    _________________________________________________________________
    dropout_4 (Dropout)          (None, 128)               0         
    _________________________________________________________________
    dense_4 (Dense)              (None, 2)                 258       
    =================================================================
    Total params: 1,048,378
    Trainable params: 1,047,870
    Non-trainable params: 508
    _________________________________________________________________

x_train.shape

(6000, 150, 150, 1)

x_test.shape

(6000, 150, 150, 1)

y_train.shape

(6000, 2)

y_test.shape

(6000, 2)

# 训练模型，载入数据，verbose=1为输出进度条记录 
    # validation_data为验证集 
    h = model.fit(x_train, y_train, 
              batch_size=batch_size, 
              epochs=epochs, 
              verbose=1, 
              validation_data=(x_test, y_test))

Train on 6000 samples, validate on 6000 samples
    Epoch 1/30
    6000/6000 [==============================] - 880s 147ms/step - loss: 0.5524 - acc: 0.7858 - val_loss: 0.5994 - val_acc: 0.7830
    Epoch 2/30
    6000/6000 [==============================] - 881s 147ms/step - loss: 0.4828 - acc: 0.7960 - val_loss: 0.6059 - val_acc: 0.7893
    Epoch 3/30
    6000/6000 [==============================] - 883s 147ms/step - loss: 0.3819 - acc: 0.7950 - val_loss: 0.7776 - val_acc: 0.7832
    Epoch 4/30
    6000/6000 [==============================] - 883s 147ms/step - loss: 0.3388 - acc: 0.8268 - val_loss: 1.3482 - val_acc: 0.7662
    Epoch 5/30
    6000/6000 [==============================] - 884s 147ms/step - loss: 0.2680 - acc: 0.8758 - val_loss: 1.1162 - val_acc: 0.7122
    Epoch 6/30
    6000/6000 [==============================] - 883s 147ms/step - loss: 0.2393 - acc: 0.8910 - val_loss: 1.2007 - val_acc: 0.7108
    Epoch 7/30
    6000/6000 [==============================] - 885s 148ms/step - loss: 0.2101 - acc: 0.9038 - val_loss: 1.7616 - val_acc: 0.7040
    Epoch 8/30
    6000/6000 [==============================] - 883s 147ms/step - loss: 0.2044 - acc: 0.9128 - val_loss: 1.4779 - val_acc: 0.7153
    Epoch 9/30
    6000/6000 [==============================] - 883s 147ms/step - loss: 0.1845 - acc: 0.9183 - val_loss: 1.7467 - val_acc: 0.7158
    Epoch 10/30
    6000/6000 [==============================] - 883s 147ms/step - loss: 0.1963 - acc: 0.9137 - val_loss: 1.8045 - val_acc: 0.7195
    Epoch 11/30
    6000/6000 [==============================] - 882s 147ms/step - loss: 0.1780 - acc: 0.9267 - val_loss: 1.8299 - val_acc: 0.7093
    Epoch 12/30
    6000/6000 [==============================] - 883s 147ms/step - loss: 0.1854 - acc: 0.9238 - val_loss: 2.1473 - val_acc: 0.7112
    Epoch 13/30
    6000/6000 [==============================] - 883s 147ms/step - loss: 0.1670 - acc: 0.9277 - val_loss: 1.8903 - val_acc: 0.7063
    Epoch 14/30
    6000/6000 [==============================] - 881s 147ms/step - loss: 0.1665 - acc: 0.9302 - val_loss: 2.2134 - val_acc: 0.7088
    Epoch 15/30
    6000/6000 [==============================] - 877s 146ms/step - loss: 0.1677 - acc: 0.9345 - val_loss: 2.3799 - val_acc: 0.7122
    Epoch 16/30
    6000/6000 [==============================] - 880s 147ms/step - loss: 0.1545 - acc: 0.9383 - val_loss: 2.1335 - val_acc: 0.7023
    Epoch 17/30
    6000/6000 [==============================] - 891s 149ms/step - loss: 0.1436 - acc: 0.9457 - val_loss: 2.1359 - val_acc: 0.7043
    Epoch 18/30
    6000/6000 [==============================] - 896s 149ms/step - loss: 0.1565 - acc: 0.9400 - val_loss: 2.2126 - val_acc: 0.7002
    Epoch 19/30
    6000/6000 [==============================] - 896s 149ms/step - loss: 0.1453 - acc: 0.9452 - val_loss: 2.1567 - val_acc: 0.6988
    Epoch 20/30
    6000/6000 [==============================] - 889s 148ms/step - loss: 0.1364 - acc: 0.9513 - val_loss: 2.2390 - val_acc: 0.6530
    Epoch 21/30
    6000/6000 [==============================] - 887s 148ms/step - loss: 0.1359 - acc: 0.9533 - val_loss: 2.4082 - val_acc: 0.6947
    Epoch 22/30
    6000/6000 [==============================] - 889s 148ms/step - loss: 0.1262 - acc: 0.9565 - val_loss: 2.3404 - val_acc: 0.6940
    Epoch 23/30
    6000/6000 [==============================] - 889s 148ms/step - loss: 0.1242 - acc: 0.9607 - val_loss: 2.4724 - val_acc: 0.7022
    Epoch 24/30
    6000/6000 [==============================] - 885s 148ms/step - loss: 0.1240 - acc: 0.9590 - val_loss: 2.0145 - val_acc: 0.6945
    Epoch 25/30
    6000/6000 [==============================] - 889s 148ms/step - loss: 0.1185 - acc: 0.9602 - val_loss: 2.7136 - val_acc: 0.6975
    Epoch 26/30
    6000/6000 [==============================] - 888s 148ms/step - loss: 0.1166 - acc: 0.9635 - val_loss: 1.9823 - val_acc: 0.7085
    Epoch 27/30
    6000/6000 [==============================] - 888s 148ms/step - loss: 0.1092 - acc: 0.9660 - val_loss: 2.5168 - val_acc: 0.6928
    Epoch 28/30
    6000/6000 [==============================] - 890s 148ms/step - loss: 0.1104 - acc: 0.9652 - val_loss: 2.2961 - val_acc: 0.6910
    Epoch 29/30
    6000/6000 [==============================] - 888s 148ms/step - loss: 0.1021 - acc: 0.9680 - val_loss: 2.7128 - val_acc: 0.6892
    Epoch 30/30
    6000/6000 [==============================] - 890s 148ms/step - loss: 0.1117 - acc: 0.9635 - val_loss: 2.4767 - val_acc: 0.6792

h.history

{'acc': [0.7858333355188369,
      0.7959999996423721,
      0.7950000017881393,
      0.8268333393335342,
      0.8758333331346512,
      0.8909999972581863,
      0.9038333308696747,
      0.9128333330154419,
      0.9183333283662796,
      0.9136666619777679,
      0.9266666650772095,
      0.9238333302736282,
      0.9276666641235352,
      0.9301666617393494,
      0.934499996304512,
      0.938333328962326,
      0.9456666594743729,
      0.9399999970197678,
      0.9451666611433029,
      0.9513333255052566,
      0.9533333265781403,
      0.9564999938011169,
      0.9606666606664658,
      0.9589999949932099,
      0.9601666617393494,
      0.9634999960660935,
      0.9659999966621399,
      0.9651666623353958,
      0.9679999923706055,
      0.9634999954700469],
     'loss': [0.5524214273691177,
      0.4828338068723679,
      0.38186915710568425,
      0.33880721509456635,
      0.2680011023581028,
      0.23933386288583278,
      0.21013603195548058,
      0.2043750958889723,
      0.1845090373978019,
      0.19625823568552733,
      0.17797948703169822,
      0.18541904892772437,
      0.16695049710571766,
      0.1664640185981989,
      0.16772418715059756,
      0.1545185938104987,
      0.14357502495869995,
      0.15649444151669742,
      0.14530771220102906,
      0.13639545898884534,
      0.13587181743234397,
      0.1261654317844659,
      0.1242364742513746,
      0.12402559936977924,
      0.11846488296985626,
      0.11660231968387962,
      0.10923483616672457,
      0.11043237544596195,
      0.10205052715726197,
      0.11170138036832214],
     'val_acc': [0.783000003695488,
      0.789333336353302,
      0.7831666684150695,
      0.7661666721105576,
      0.7121666634082794,
      0.710833330154419,
      0.7039999985694885,
      0.7153333294391632,
      0.7158333289623261,
      0.7194999957084656,
      0.7093333303928375,
      0.7111666625738144,
      0.7063333308696746,
      0.7088333314657211,
      0.7121666657924652,
      0.7023333317041397,
      0.7043333286046982,
      0.7001666635274887,
      0.6988333338499069,
      0.6530000001192093,
      0.6946666669845581,
      0.6940000009536743,
      0.7021666640043258,
      0.6944999998807907,
      0.6974999964237213,
      0.7084999960660935,
      0.6928333306312561,
      0.6909999978542328,
      0.6891666674613952,
      0.6791666603088379],
     'val_loss': [0.5994120141863823,
      0.6058913320302963,
      0.7776326471567154,
      1.3482153457403183,
      1.1162475830316543,
      1.200699964761734,
      1.7615546423196793,
      1.4779181623458861,
      1.7466648763418198,
      1.8044967579841613,
      1.8298623532056808,
      2.1473262298107145,
      1.8902902138233184,
      2.213402044773102,
      2.3799089360237122,
      2.1334830605983734,
      2.135851370692253,
      2.2125678730010985,
      2.1567417573928833,
      2.2389502900838854,
      2.4081826680898666,
      2.3403765678405763,
      2.4724018812179565,
      2.01446248292923,
      2.7136144387722014,
      1.9822845512628555,
      2.5167795360088348,
      2.2961159819364547,
      2.712822151184082,
      2.476669762134552]}

# 开始评估模型效果
    # verbose=0为不输出日志信息 
    score = model.evaluate(x_test, y_test, verbose=0) 
    model.save('url_model.h5')
    print('Test loss:', score[0]) 
    print('Test accuracy:', score[1])

Test loss: 2.4766697918574017
    Test accuracy: 0.6791666666666667

a = [0.783000003695488,
      0.789333336353302,
      0.7831666684150695,
      0.7661666721105576,
      0.7121666634082794,
      0.710833330154419,
      0.7039999985694885,
      0.7153333294391632,
      0.7158333289623261,
      0.7194999957084656,
      0.7093333303928375,
      0.7111666625738144,
      0.7063333308696746,
      0.7088333314657211,
      0.7121666657924652,
      0.7023333317041397,
      0.7043333286046982,
      0.7001666635274887,
      0.6988333338499069,
      0.6530000001192093,
      0.6946666669845581,
      0.6940000009536743,
      0.7021666640043258,
      0.6944999998807907,
      0.6974999964237213,
      0.7084999960660935,
      0.6928333306312561,
      0.6909999978542328,
      0.6891666674613952,
      0.6791666603088379]

import matplotlib.pyplot as plt

length = len(a)

length

b = list(range(length))

plt.scatter(b,a)

<matplotlib.collections.PathCollection at 0x7a9b2b0>

![png][]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzU3NTA5_size_16_color_FFFFFF_t_70]

## keras 一维卷积 ##

from __future__ import absolute_import
    from __future__ import print_function
    from __future__ import division
    
    import numpy as np
    import pandas as pd
    import tensorflow as tf
    import keras

Using TensorFlow backend.

#### 读取数据 ####

train_data_path = r"E:/ml_program/网安实验/New-6000/Train.csv"
    train_label_path = r"E:/ml_program/网安实验/New-6000/Label_Train.csv"
    test_data_path = r"E:/ml_program/网安实验/New-6000/Test.csv"
    test_label_path = r"E:/ml_program/网安实验/New-6000/Label_Test.csv"
    
    x_train = pd.read_csv(train_data_path,header=None)
    y_train = pd.read_csv(train_label_path,header=None)
    x_test = pd.read_csv(test_data_path,header=None)
    y_test = pd.read_csv(test_label_path,header=None)

x_train.info()

<class 'pandas.core.frame.DataFrame'>
    RangeIndex: 6000 entries, 0 to 5999
    Columns: 22500 entries, 0 to 22499
    dtypes: float64(22500)
    memory usage: 1.0 GB

#### 降维 ####

from sklearn.decomposition import PCA
    pca = PCA(n_components=3000)
    pca.fit(x_train)

PCA(copy=True, iterated_power='auto', n_components=3000, random_state=None,
      svd_solver='auto', tol=0.0, whiten=False)

train_data = pca.transform(x_train)
    test_data = pca.transform(x_test)

train_data.shape

(6000, 3000)

test_data.shape

(6000, 3000)

train_data

array([[-1.81527935e+01, -1.68876010e+01,  5.89910488e+00, ...,
            -1.58482829e-16,  2.02504931e-16,  2.47220542e-16],
           [-1.11560155e+01,  1.29328603e+02,  8.83608427e+01, ...,
             6.11734394e-16, -4.01634256e-15,  3.65074800e-15],
           [ 1.53021653e+01,  4.69284398e+01, -6.82044380e+01, ...,
            -5.19305312e-16,  1.46993780e-16,  7.19065327e-16],
           ...,
           [-2.04582268e+01, -2.92633562e+01,  1.86088607e+01, ...,
             8.40717893e-16, -1.02806401e-16, -2.10746456e-16],
           [-1.36213043e+01, -1.55326236e+01,  3.35855227e+00, ...,
            -4.74605266e-17,  5.35571839e-16, -2.94013183e-16],
           [ 1.15019183e+02, -2.10036408e+01,  1.09317328e+01, ...,
            -8.26785048e-16,  2.74929636e-16,  1.36785191e-15]])

#### 数据的标准化处理 ####

train_data -= train_data.min()

train_data /= train_data.max() - train_data.min()

train_data

array([[0.39861644, 0.40124638, 0.44861287, ..., 0.43635046, 0.43635046,
            0.43635046],
           [0.41316057, 0.70518447, 0.62002522, ..., 0.43635046, 0.43635046,
            0.43635046],
           [0.46815891, 0.53390012, 0.29457461, ..., 0.43635046, 0.43635046,
            0.43635046],
           ...,
           [0.39382416, 0.37552103, 0.4750325 , ..., 0.43635046, 0.43635046,
            0.43635046],
           [0.408036  , 0.40406296, 0.44333185, ..., 0.43635046, 0.43635046,
            0.43635046],
           [0.67543963, 0.39269041, 0.45907414, ..., 0.43635046, 0.43635046,
            0.43635046]])

train_data_ = np.expand_dims(train_data,axis=2)
    test_data_ = np.expand_dims(test_data,axis=2)

import keras 
    from keras.models import Sequential 
    from keras import layers
    from keras import metrics, losses
    from keras.optimizers import RMSprop

model = Sequential()
    model.add(layers.Conv1D(32, 9, activation='relu', input_shape=(3000, 1)))
    # model.add(layers.Conv1D(16, 9, activation='relu'))
    model.add(layers.MaxPooling1D(5))
    
    model.add(layers.Dropout(0.3)) 
    
    model.add(layers.Conv1D(64, 5, activation='relu'))
    # model.add(layers.Conv1D(64, 7, activation='relu'))
    model.add(layers.MaxPooling1D(5))
    
    model.add(layers.Dropout(0.3)) 
    
    # model.add(layers.Conv1D(16, 5, activation='relu')) 
    # model.add(layers.Conv1D(16, 5, activation='relu')) 
    model.add(layers.GlobalAveragePooling1D()) 
    
    model.add(layers.Dropout(0.3)) 
    
    model.add(layers.Dense(2, activation='softmax'))

model.compile(optimizer=RMSprop(lr=1e-4),
                 loss='categorical_crossentropy',
                 metrics=['acc'])

history = model.fit(train_data_,
                        np.array(y_train),
                        epochs=10,
                        batch_size=128,
                        validation_split=0.1
                        )

Train on 5400 samples, validate on 600 samples
    Epoch 1/10
    5400/5400 [==============================] - 14s 3ms/step - loss: 0.6081 - acc: 0.7839 - val_loss: 0.5949 - val_acc: 0.7783
    Epoch 2/10
    5400/5400 [==============================] - 13s 2ms/step - loss: 0.5389 - acc: 0.7935 - val_loss: 0.5502 - val_acc: 0.7783
    Epoch 3/10
    5400/5400 [==============================] - 13s 2ms/step - loss: 0.5166 - acc: 0.7935 - val_loss: 0.5369 - val_acc: 0.7783
    Epoch 4/10
    5400/5400 [==============================] - 13s 2ms/step - loss: 0.5138 - acc: 0.7935 - val_loss: 0.5367 - val_acc: 0.7783
    Epoch 5/10
    5400/5400 [==============================] - 13s 2ms/step - loss: 0.5126 - acc: 0.7935 - val_loss: 0.5347 - val_acc: 0.7783
    Epoch 6/10
    5400/5400 [==============================] - 14s 3ms/step - loss: 0.5127 - acc: 0.7935 - val_loss: 0.5365 - val_acc: 0.7783
    Epoch 7/10
    5400/5400 [==============================] - 13s 2ms/step - loss: 0.5109 - acc: 0.7935 - val_loss: 0.5344 - val_acc: 0.7783
    Epoch 8/10
    5400/5400 [==============================] - 13s 2ms/step - loss: 0.5140 - acc: 0.7935 - val_loss: 0.5385 - val_acc: 0.7783
    Epoch 9/10
    5400/5400 [==============================] - 13s 2ms/step - loss: 0.5116 - acc: 0.7935 - val_loss: 0.5380 - val_acc: 0.7783
    Epoch 10/10
    5400/5400 [==============================] - 14s 3ms/step - loss: 0.5110 - acc: 0.7935 - val_loss: 0.5385 - val_acc: 0.7783

history.history

{'acc': [0.7838888888005857,
      0.7935185185185185,
      0.7935185184302154,
      0.7935185186068217,
      0.7935185186068217,
      0.7935185185185185,
      0.7935185186068217,
      0.7935185184302154,
      0.7935185186068217,
      0.7935185185185185],
     'loss': [0.608099317462356,
      0.5388645154016989,
      0.5166198704860828,
      0.5137703606817458,
      0.5126361263239825,
      0.5127095956272549,
      0.5109285568307947,
      0.5139557931158277,
      0.5116121105794553,
      0.5110090099440681],
     'val_acc': [0.7783333317438761,
      0.7783333317438761,
      0.7783333317438761,
      0.7783333317438761,
      0.7783333317438761,
      0.7783333317438761,
      0.7783333317438761,
      0.7783333317438761,
      0.7783333317438761,
      0.7783333317438761],
     'val_loss': [0.5948915068308512,
      0.5501580595970154,
      0.5368749721844991,
      0.536713076432546,
      0.5347341251373291,
      0.5364996202786764,
      0.5344381523132324,
      0.5385403855641683,
      0.5379774792989095,
      0.5384526300430298]}

score = model.evaluate(test_data_,y_test,verbose=0)
    score

[0.7018050424257914, 0.7898333333333334]

## Keras 2维卷积 ##

from __future__ import absolute_import
    from __future__ import division
    from __future__ import print_function
    import tensorflow as tf
    import numpy as np
    import pandas as pd
    import keras
    import seaborn as sns # 导入python 数据可视化库 seaborn
    # 功能是可以内嵌绘图
    %matplotlib inline 
    %config InlineBackend.figure_format = 'svg' # 提高生成图像的质量
    sns.set_style("darkgrid") # 设置可视化主题，共有五个：darkgrid , whitegrid , dark , white ,和 ticks  默认： darkgrid

x_train.info()

<class 'pandas.core.frame.DataFrame'>
    RangeIndex: 6000 entries, 0 to 5999
    Columns: 22500 entries, 0 to 22499
    dtypes: float64(22500)
    memory usage: 1.0 GB

x_test.info()

<class 'pandas.core.frame.DataFrame'>
    RangeIndex: 6000 entries, 0 to 5999
    Columns: 22500 entries, 0 to 22499
    dtypes: float64(22500)
    memory usage: 1.0 GB

x_test.head()

5 rows × 22500 columns

from sklearn.decomposition import PCA

pca = PCA(n_components=1024)
    pca.fit(x_train)

PCA(copy=True, iterated_power='auto', n_components=1024, random_state=None,
      svd_solver='auto', tol=0.0, whiten=False)

train_data = pca.transform(x_train)

train_data.shape

(6000, 1024)

test_data = pca.transform(x_test)

test_data.shape

(6000, 1024)

train_data -= train_data.min()
    train_data /= train_data.max() - train_data.min()
    train_data

array([[0.39861644, 0.40124638, 0.44861287, ..., 0.43635129, 0.43634979,
            0.43634985],
           [0.41316057, 0.70518447, 0.62002522, ..., 0.43644287, 0.43604486,
            0.43635684],
           [0.46815891, 0.53390012, 0.29457461, ..., 0.43659403, 0.43601981,
            0.43647812],
           ...,
           [0.39382416, 0.37552103, 0.4750325 , ..., 0.4363989 , 0.43630845,
            0.43632915],
           [0.408036  , 0.40406296, 0.44333185, ..., 0.43636385, 0.43635638,
            0.43635107],
           [0.67543963, 0.39269041, 0.45907414, ..., 0.43635207, 0.43633675,
            0.43636958]])

test_data -= test_data.min()
    test_data /= test_data.max() - test_data.min()
    test_data

array([[0.42625771, 0.61878675, 0.55129311, ..., 0.43661809, 0.43872784,
            0.4388704 ],
           [0.42954677, 0.61620632, 0.55290143, ..., 0.436605  , 0.43993221,
            0.43942426],
           [0.47245826, 0.54235909, 0.28730559, ..., 0.43836862, 0.43876131,
            0.43842725],
           ...,
           [0.41396939, 0.45479018, 0.41870971, ..., 0.43879874, 0.43879621,
            0.43879996],
           [0.41400996, 0.71965537, 0.63039757, ..., 0.43662198, 0.4389945 ,
            0.43929315],
           [0.44262412, 0.50971554, 0.30260149, ..., 0.43878874, 0.43887957,
            0.43878863]])

# 使用Sequential模型
    from keras.models import Sequential
    from keras.layers import Conv2D,Dense,MaxPool2D,Dropout,Flatten,MaxPooling2D

input_shape = (32,32,1)

# 使用Sequential模型
    model = Sequential()
    model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=input_shape))
    # 加最大值池化
    model.add(MaxPooling2D(pool_size=(2, 2)))
    
    # 再加一层卷积，64个卷积核
    model.add(Conv2D(64, (3, 3), activation='relu'))
    # 加最大值池化
    model.add(MaxPooling2D(pool_size=(3, 3)))
    
    # 加Dropout，断开神经元比例为25%
    model.add(Dropout(0.25))
    # 加Flatten，数据一维化
    model.add(Flatten())
    
    # 加Dense，输出128维
    model.add(Dense(128, activation='relu'))
    
    # 再一次Dropout
    model.add(Dropout(0.5))
    
    # 最后一层为Softmax，输出为2个分类的概率
    model.add(Dense(2, activation='softmax'))

model.summary()

train_data.shape

(6000, 1024)

train_data_ = train_data.reshape(train_data.shape[0],32,32,1)
    test_data_ = test_data.reshape(test_data.shape[0],32,32,1)

# 训练模型，载入数据，verbose=1为输出进度条记录 
    # validation_data为验证集 
    h = model.fit(train_data_, 
              np.array(y_train), 
              batch_size=128, 
              epochs=10, 
              verbose=1, 
              validation_data=(test_data_, np.array(y_test)))

Train on 6000 samples, validate on 6000 samples
    Epoch 1/10
    6000/6000 [==============================] - 13s 2ms/step - loss: 0.5350 - acc: 0.7823 - val_loss: 0.5155 - val_acc: 0.7898
    Epoch 2/10
    6000/6000 [==============================] - 6s 1ms/step - loss: 0.5223 - acc: 0.7920 - val_loss: 0.5193 - val_acc: 0.7898
    Epoch 3/10
    6000/6000 [==============================] - 6s 974us/step - loss: 0.5182 - acc: 0.7920 - val_loss: 0.5153 - val_acc: 0.7898
    Epoch 4/10
    6000/6000 [==============================] - 6s 973us/step - loss: 0.5217 - acc: 0.7920 - val_loss: 0.5173 - val_acc: 0.7898
    Epoch 5/10
    6000/6000 [==============================] - 6s 978us/step - loss: 0.5205 - acc: 0.7920 - val_loss: 0.5167 - val_acc: 0.7898
    Epoch 6/10
    6000/6000 [==============================] - 6s 976us/step - loss: 0.5177 - acc: 0.7920 - val_loss: 0.5158 - val_acc: 0.7898
    Epoch 7/10
    6000/6000 [==============================] - 6s 1ms/step - loss: 0.5156 - acc: 0.7920 - val_loss: 0.5267 - val_acc: 0.7898
    Epoch 8/10
    6000/6000 [==============================] - 6s 977us/step - loss: 0.5184 - acc: 0.7920 - val_loss: 0.5149 - val_acc: 0.7898
    Epoch 9/10
    6000/6000 [==============================] - 6s 981us/step - loss: 0.5189 - acc: 0.7920 - val_loss: 0.5217 - val_acc: 0.7898
    Epoch 10/10
    6000/6000 [==============================] - 6s 976us/step - loss: 0.5163 - acc: 0.7920 - val_loss: 0.5149 - val_acc: 0.7898

score = model.evaluate(test_data_,y_test,verbose=0)
    score

[0.5148901407718658, 0.7898333333333334]

h.history

{'acc': [0.7823333334922791,
      0.7920000003178914,
      0.7920000001589457,
      0.7920000003178914,
      0.7920000003178914,
      0.7919999995231628,
      0.7919999995231628,
      0.792,
      0.7920000004768372,
      0.7920000001589457],
     'loss': [0.5349862392743429,
      0.5222909445762635,
      0.5182188127835592,
      0.521706653436025,
      0.5205274223486582,
      0.5176767088572184,
      0.5156365902423858,
      0.5184187761147817,
      0.5188696700731913,
      0.5163108186721802],
     'val_acc': [0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876],
     'val_loss': [0.5155299636522929,
      0.5193401981989543,
      0.515339590549469,
      0.5173060723940531,
      0.5166788649559021,
      0.5157660571734111,
      0.5267293423016866,
      0.5148910369873047,
      0.5217333490053813,
      0.5148901314735412]}

a = [0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876,
      0.7898333331743876]

lenth = len(a)
    b = list(range(lenth))

import matplotlib.pyplot as plt
    plt.plot(b, a, 'b*')

[<matplotlib.lines.Line2D at 0x30fa9390>]

![svg][png]

def drawPic(history):
        acc = history.history['acc']
        val_acc = history.history['val_acc']
        loss = history.history['loss']
        val_loss = history.history['val_loss']
        epochs = range(1, len(acc) + 1)
        fig, ax = plt.subplots(2, 1, sharex=True)
    
        ax[0].plot(epochs, acc, 'r*', label='Training acc')
        ax[0].plot(epochs, val_acc, 'b', label='Validation acc')
        ax[0].set_title('Training and Validation accuracy')
        ax[0].set_ylabel('accuracy')
        ax[0].set_ylim(0.5, 1)
        ax[0].set_xlim(1, 10)
        ax[0].legend(loc='best')
    
        ax[1].set_title('Training and validation loss')
        ax[1].set_ylabel('loss')
        ax[1].set_ylim(0.3, 0.8)
        ax[1].plot(epochs, loss, 'r>', label='Training loss')
        ax[1].plot(epochs, val_loss, 'b', label='Validation loss')
        ax[1].legend(loc='best')
    
        plt.ylabel("epochs")
        fig.tight_layout()

drawPic(h)

![svg][png]

# Traditional machine learning methods
    from sklearn.linear_model import LogisticRegression
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import classification_report
    from sklearn.metrics import accuracy_score
    from sklearn import metrics

model = LogisticRegression()
    model.fit(train_data, y_train.iloc[:, 0])
    pred = model.predict(test_data)
    accs = accuracy_score(y_test.iloc[:, 0], pred)
    print("Accuracy Score: ", accs)
    fpr, tpr, _ = metrics.roc_curve(y_test.iloc[:,0],  pred)
    auc = metrics.roc_auc_score(y_test.iloc[:,0], pred) #Find AUC score for the data set based on LR
    print("AUC Score: ", auc)
    _ = plt.plot(fpr, tpr, label="bad-good auc="+str(auc))
    _ = plt.legend(loc=4)
    _ = plt.title("ROC curve")

d:\programdata\anaconda3\envs\testconda\lib\site-packages\sklearn\linear_model\logistic.py:432: FutureWarning: Default solver will be changed to 'lbfgs' in 0.22. Specify a solver to silence this warning.
      FutureWarning)
    
    
    Accuracy Score:  0.7963333333333333
    AUC Score:  0.5218659882504314

![svg][png]

target_names = ['good', 'bad']
    print(classification_report(y_test.iloc[:,0], pred, target_names=target_names))

precision    recall  f1-score   support
    
            good       0.80      1.00      0.89      4739
             bad       0.73      0.05      0.09      1261
    
       micro avg       0.80      0.80      0.80      6000
       macro avg       0.77      0.52      0.49      6000
    weighted avg       0.78      0.80      0.72      6000

[png]: 
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzU3NTA5_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20181118190722225.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzU3NTA5,size_16,color_FFFFFF,t_70