keras深度学习_迁移学习 神经网络 深度学习 keras - CSDN
  • 本章节通过深度学习框架TensorFlow和Keras框架原理知识的介绍,框架的搭建,并通过案例的讲解,掌握深度学习框架的运用。
  • Keras是一种高度模块化,使用简单上手快,合适深度学习初学者使用的深度学习框架。Keras由纯Python编写而成并以Tensorflow、Theano以及CNTK为后端。Keras为支持实验而生,能够把你的idea迅速转换为结果。 对于深度...
  • 使用keras深度学习来分类白葡萄酒还是红葡萄酒 首先介绍一下数据类型: 1.这个数据集包含了1599种红酒,4898种白酒; 2.输入数据特征: 1 - fixed acidity 2 - volatile acidity 3 - citric acid 4 - ...

    使用keras的深度学习来分类白葡萄酒还是红葡萄酒

    首先介绍一下数据类型:

    1.这个数据集包含了1599种红酒,4898种白酒;
    2.输入数据特征:
    1 - fixed acidity
    2 - volatile acidity
    3 - citric acid
    4 - residual sugar
    5 - chlorides
    6 - free sulfur dioxide
    7 - total sulfur dioxide
    8 - density
    9 - pH
    10 - sulphates
    11 - alcohol
    3.输出变量:
    12 - quality (score between 0 and 10)

    import pandas as pd
    #导入数据
    white = pd.read_csv("http://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv", sep=';')
    
    red = pd.read_csv("http://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-red.csv", sep=';')
    #查看白酒信息
    print white.info()
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 4898 entries, 0 to 4897
    Data columns (total 12 columns):
    fixed acidity           4898 non-null float64
    volatile acidity        4898 non-null float64
    citric acid             4898 non-null float64
    residual sugar          4898 non-null float64
    chlorides               4898 non-null float64
    free sulfur dioxide     4898 non-null float64
    total sulfur dioxide    4898 non-null float64
    density                 4898 non-null float64
    pH                      4898 non-null float64
    sulphates               4898 non-null float64
    alcohol                 4898 non-null float64
    quality                 4898 non-null int64
    dtypes: float64(11), int64(1)
    memory usage: 459.3 KB
    None
    
    #查看红酒信息
    print red.info()
    <class 'pandas.core.frame.DataFrame'>
    RangeIndex: 1599 entries, 0 to 1598
    Data columns (total 12 columns):
    fixed acidity           1599 non-null float64
    volatile acidity        1599 non-null float64
    citric acid             1599 non-null float64
    residual sugar          1599 non-null float64
    chlorides               1599 non-null float64
    free sulfur dioxide     1599 non-null float64
    total sulfur dioxide    1599 non-null float64
    density                 1599 non-null float64
    pH                      1599 non-null float64
    sulphates               1599 non-null float64
    alcohol                 1599 non-null float64
    quality                 1599 non-null int64
    dtypes: float64(11), int64(1)
    memory usage: 150.0 KB
    None
    
    #查看具体值
    print red.head()
       fixed acidity  volatile acidity  citric acid  residual sugar  chlorides  \
    0            7.4              0.70         0.00             1.9      0.076   
    1            7.8              0.88         0.00             2.6      0.098   
    2            7.8              0.76         0.04             2.3      0.092   
    3           11.2              0.28         0.56             1.9      0.075   
    4            7.4              0.70         0.00             1.9      0.076   
    
       free sulfur dioxide  total sulfur dioxide  density    pH  sulphates  \
    0                 11.0                  34.0   0.9978  3.51       0.56   
    1                 25.0                  67.0   0.9968  3.20       0.68   
    2                 15.0                  54.0   0.9970  3.26       0.65   
    3                 17.0                  60.0   0.9980  3.16       0.58   
    4                 11.0                  34.0   0.9978  3.51       0.56   
    
       alcohol  quality  
    0      9.4        5  
    1      9.8        5  
    2      9.8        5  
    3      9.8        6  
    4      9.4        5  
    
    #查看各行统计信息
    print red.describe()
           fixed acidity  volatile acidity  citric acid  residual sugar  \
    count    1599.000000       1599.000000  1599.000000     1599.000000   
    mean        8.319637          0.527821     0.270976        2.538806   
    std         1.741096          0.179060     0.194801        1.409928   
    min         4.600000          0.120000     0.000000        0.900000   
    25%         7.100000          0.390000     0.090000        1.900000   
    50%         7.900000          0.520000     0.260000        2.200000   
    75%         9.200000          0.640000     0.420000        2.600000   
    max        15.900000          1.580000     1.000000       15.500000   
    
             chlorides  free sulfur dioxide  total sulfur dioxide      density  \
    count  1599.000000          1599.000000           1599.000000  1599.000000   
    mean      0.087467            15.874922             46.467792     0.996747   
    std       0.047065            10.460157             32.895324     0.001887   
    min       0.012000             1.000000              6.000000     0.990070   
    25%       0.070000             7.000000             22.000000     0.995600   
    50%       0.079000            14.000000             38.000000     0.996750   
    75%       0.090000            21.000000             62.000000     0.997835   
    max       0.611000            72.000000            289.000000     1.003690   
    
                    pH    sulphates      alcohol      quality  
    count  1599.000000  1599.000000  1599.000000  1599.000000  
    mean      3.311113     0.658149    10.422983     5.636023  
    std       0.154386     0.169507     1.065668     0.807569  
    min       2.740000     0.330000     8.400000     3.000000  
    25%       3.210000     0.550000     9.500000     5.000000  
    50%       3.310000     0.620000    10.200000     6.000000  
    75%       3.400000     0.730000    11.100000     6.000000  
    max       4.010000     2.000000    14.900000     8.000000  
    
    import numpy as np
    #查看是否有数据缺失
    print np.any(red.isnull()==True)
    False
    
    print np.any(white.isnull()==True)
    False
    
    #可视化数据
    import matplotlib.pyplot as plt
    
    fig,ax = plt.subplots(1,2)
    
    ax[0].hist(red.alcohol, 10, facecolor='red', alpha=0.5, label="Red wine")
    ax[1].hist(white.alcohol, 10, facecolor='white', ec="black", lw=0.5, alpha=0.5, label="White wine")
    
    fig.subplots_adjust(left=0, right=1, bottom=0, top=0.5, hspace=0.05, wspace=1)
    ax[0].set_ylim([0, 1000])
    ax[0].set_xlabel("Alcohol in % Vol")
    ax[0].set_ylabel("Frequency")
    ax[1].set_xlabel("Alcohol in % Vol")
    ax[1].set_ylabel("Frequency")
    ax[0].legend(loc='best')
    ax[1].legend(loc='best')
    fig.suptitle("Distribution of Alcohol in % Vol")
    
    plt.show()

    这里写图片描述

    我们可以从图中看出红酒和白酒的酒精浓度基本上9%左右。

    #处理数据
    #给我们的数据添加标签
    red['label'] = 1
    white['label'] = 0
    wines = red.append(white,ignore_index=True) #合并index顺序
    import seaborn as sns
    %matplotlib inline
    
    corr = wines.corr() #计算协方差
    sns.heatmap(corr,
               xticklabels = corr.columns.values,
               yticklabels = corr.columns.values)
    sns.plt.show() #plt.show()
    ---------------------------------------------------------------------------
    
    AttributeError                            Traceback (most recent call last)
    
    <ipython-input-18-5a30364cdd9b> in <module>()
          5            xticklabels = corr.columns.values,
          6            yticklabels = corr.columns.values)
    ----> 7 sns.plt.show()
    
    
    AttributeError: 'module' object has no attribute 'plt'
    

    这里写图片描述
    这边改成plt.show()就不会报错了!

    从图中我们可以看到各个特征之间的相关性,从中我们可以发现density跟residual sugar是正相关的,而跟alcohol是负相关的。

    #划分训练集合测试集
    from sklearn.model_selection import train_test_split
    X = wines.iloc[:,0:11]
    y = np.ravel(wines.label) #降成一维,类似np.flatten(),但是np.flatten是拷贝,而ravel是引用
    
    #随机划分训练集和测试集
    #test_size:测试集占比
    #random_state:随机种子,在需要重复试验的时候,保证得到一组一样的随机数。
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.33, random_state=32)
    #标准化数据
    from sklearn.preprocessing import StandardScaler
    
    scaler = StandardScaler().fit(X_train)
    
    X_train = scaler.transform(X_train)
    
    X_test = scaler.transform(X_test)
    #使用keras模型化数据
    from keras.models import Sequential
    from keras.layers import Dense
    
    model = Sequential()
    #添加输入层
    model.add(Dense(12,activation='relu',
                   input_shape=(11,)))
    #添加隐藏层
    model.add(Dense(8,activation='relu'))
    
    #添加输出层
    model.add(Dense(1,activation='sigmoid'))
    Using TensorFlow backend.
    
    #查看模型
    #查看输出维度
    print model.output_shape
    (None, 1)
    
    #查看整个模型
    print model.summary()
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    dense_1 (Dense)              (None, 12)                144       
    _________________________________________________________________
    dense_2 (Dense)              (None, 8)                 104       
    _________________________________________________________________
    dense_3 (Dense)              (None, 1)                 9         
    =================================================================
    Total params: 257
    Trainable params: 257
    Non-trainable params: 0
    _________________________________________________________________
    None
    
    #查看模型参数
    print model.get_weights()
    #模型的训练
    model.compile(loss='binary_crossentropy',
                 optimizer='adam',
                 metrics=['accuracy'])
    #verbose = 1 查看输出过程 
    model.fit(X_train,y_train,epochs=30,batch_size=1,verbose=1)
    Epoch 1/30
    4352/4352 [==============================] - 15s - loss: 0.1108 - acc: 0.9614    
    Epoch 2/30
    4352/4352 [==============================] - 15s - loss: 0.0255 - acc: 0.9952    
    Epoch 3/30
    4352/4352 [==============================] - 15s - loss: 0.0195 - acc: 0.9954    
    Epoch 4/30
    4352/4352 [==============================] - 15s - loss: 0.0180 - acc: 0.9966    
    Epoch 5/30
    4352/4352 [==============================] - 15s - loss: 0.0166 - acc: 0.9966    
    Epoch 6/30
    4352/4352 [==============================] - 15s - loss: 0.0147 - acc: 0.9970    
    Epoch 7/30
    4352/4352 [==============================] - 15s - loss: 0.0132 - acc: 0.9968    
    Epoch 8/30
    4352/4352 [==============================] - 15s - loss: 0.0137 - acc: 0.9970    
    Epoch 9/30
    4352/4352 [==============================] - 16s - loss: 0.0136 - acc: 0.9975    
    Epoch 10/30
    4352/4352 [==============================] - 15s - loss: 0.0125 - acc: 0.9975    
    Epoch 11/30
    4352/4352 [==============================] - 15s - loss: 0.0113 - acc: 0.9972    
    Epoch 12/30
    4352/4352 [==============================] - 15s - loss: 0.0116 - acc: 0.9972    
    Epoch 13/30
    4352/4352 [==============================] - 15s - loss: 0.0115 - acc: 0.9975    
    Epoch 14/30
    4352/4352 [==============================] - 15s - loss: 0.0108 - acc: 0.9972    
    Epoch 15/30
    4352/4352 [==============================] - 16s - loss: 0.0097 - acc: 0.9975    
    Epoch 16/30
    4352/4352 [==============================] - 16s - loss: 0.0098 - acc: 0.9977    
    Epoch 17/30
    4352/4352 [==============================] - 15s - loss: 0.0101 - acc: 0.9975    
    Epoch 18/30
    4352/4352 [==============================] - 15s - loss: 0.0095 - acc: 0.9970    
    Epoch 19/30
    4352/4352 [==============================] - 15s - loss: 0.0088 - acc: 0.9977    
    Epoch 20/30
    4352/4352 [==============================] - 16s - loss: 0.0089 - acc: 0.9972    
    Epoch 21/30
    4352/4352 [==============================] - 16s - loss: 0.0086 - acc: 0.9977    
    Epoch 22/30
    4352/4352 [==============================] - 16s - loss: 0.0078 - acc: 0.9982    
    Epoch 23/30
    4352/4352 [==============================] - 16s - loss: 0.0085 - acc: 0.9979    
    Epoch 24/30
    4352/4352 [==============================] - 15s - loss: 0.0072 - acc: 0.9984    
    Epoch 25/30
    4352/4352 [==============================] - 16s - loss: 0.0074 - acc: 0.9982    
    Epoch 26/30
    4352/4352 [==============================] - 15s - loss: 0.0071 - acc: 0.9986    
    Epoch 27/30
    4352/4352 [==============================] - 16s - loss: 0.0080 - acc: 0.9977    
    Epoch 28/30
    4352/4352 [==============================] - 16s - loss: 0.0066 - acc: 0.9982    
    Epoch 29/30
    4352/4352 [==============================] - 16s - loss: 0.0084 - acc: 0.9982    
    Epoch 30/30
    4352/4352 [==============================] - 15s - loss: 0.0067 - acc: 0.9989    
    
    
    
    
    
    <keras.callbacks.History at 0x120530a90>
    
    #预测结果
    y_pred = model.predict(X_test)
    print y_pred[:10]
    [[  2.14960589e-03]
     [  6.35436322e-07]
     [  1.82669051e-03]
     [  2.15678483e-07]
     [  1.00000000e+00]
     [  1.84882566e-07]
     [  1.13470778e-04]
     [  5.90343404e-07]
     [  2.01183035e-08]
     [  1.00000000e+00]]
    
    print y_test[:10]
    [0 0 0 0 1 0 0 0 0 1]
    

    可以从上述结果可以看出,测试集的前十项结果跟我们预测的结果是一样的。

    #模型评估
    score = model.evaluate(X_test,y_test,verbose=1)
    
    #socre的两个值分别代表损失(loss)和精准度(accuracy)
    print score
     960/2145 [============>.................] - ETA: 0s[0.030568929157742158, 0.99580419580419577]
    
    #统计Precision、Recall、F1值
    from sklearn.metrics import confusion_matrix,precision_score,recall_score,f1_score
    
    y_pred = y_pred.astype(int) #转化成整型
    print confusion_matrix(y_test,y_pred)
    [[1633    0]
     [ 230  282]]
    
    #precision
    precision = precision_score(y_test,y_pred)
    print precision
    1.0
    
    #Recall
    recall = recall_score(y_test,y_pred)
    print recall
    0.55078125
    
    #F1 score
    f1 = f1_score(y_test,y_pred)
    print f1
    0.710327455919
    

    从上面的结果来看我们的Precision很高,但是我们的Recall值比较低。
    对此我后面还会写一篇blog来优化模型。

    展开全文
  • 一、这个IMDB数据集包含了50000条电影评论,其中25000条用于训练,另外25000条用于测试...from keras.datasets import imdb (train_data,train_labels),(test_data,test_labels) = imdb.load_data(num_words=8000) ...

    一、这个IMDB数据集包含了50000条电影评论,其中25000条用于训练,另外25000条用于测试。其label只包含0或1,其中0表示负面评价,1表示正面评价

    from keras.datasets import imdb
    (train_data,train_labels),(test_data,test_labels) = imdb.load_data(num_words=8000) #前8000个单词(每局评论至多包含8000个单词)

    二、数据集的相关信息

    print('shape of train data is ',train_data.shape)
    print('shape of train labels is ',train_labels.shape)
    print('an example of train data is ',train_data[5])
    shape of train data is  (25000,)
    shape of train labels is  (25000,)
    an example of train data is  [1, 778, 128, 74, 12, 630, 163, 15, 4, 1766, 7982, 1051, 2, 32, 85, 156, 45, 40, 148, 139, 121, 664, 665, 10, 10, 1361, 173, 4, 749, 2, 16, 3804, 8, 4, 226, 65, 12, 43, 127, 24, 2, 10, 10]
    

    三、处理数据集

    import numpy as np
    # 神经网络的输入必须是tensor而不是list,所以需要将数据集处理为25000*8000
    def vectorize_sequences(sequences,dimension=8000):
        # 生成25000*8000的二维Numpy数组
        results = np.zeros((len(sequences),dimension))
        # one-hot编码
        for i,sequence in enumerate(sequences):
            results[i,sequence] = 1.
        return results
    x_train = vectorize_sequences(train_data)
    x_test = vectorize_sequences(test_data)
    y_train = np.asarray(train_labels).astype('float32')
    y_test = np.asarray(test_labels).astype('float32')

    四、设计网络结构

    • 对于一个输入为向量的二分类问题,使用relu做为激活函数的全连接网络可以很好的解决这个问题
    • 输出层使用sigmoid的目的是使网络输出的是介于0到1的一个概率值
    • 对于二分类问题,通常使用binary_crossentropy
    from keras import models
    from keras import layers
    def build_model():
        model = models.Sequential()
        model.add(layers.Dense(16,activation='relu',input_shape=(8000,)))
        model.add(layers.Dense(16,activation='relu'))
        model.add(layers.Dense(1,activation='sigmoid'))
        model.compile(optimizer='rmsprop',# 还可以通过optimizer = optimizers.RMSprop(lr=0.001)来为优化器指定参数
                      loss='binary_crossentropy', # 等价于loss = losses.binary_crossentropy
                      metrics=['accuracy']) # 等价于metrics = [metircs.binary_accuracy]
        return model
    model = build_model()

    五、划分验证集用于选择超参数epochs

    x_val = x_train[:10000]
    partial_x_train = x_train[10000:]
    y_val = y_train[:10000]
    partial_y_train = y_train[10000:]

    六、训练模型

    history = model.fit(partial_x_train,
                        partial_y_train,
                        epochs=20, # 在全数据集上迭代20次
                        batch_size=512, # 每个batch的大小为512
                        validation_data=(x_val,y_val))
    Train on 15000 samples, validate on 10000 samples
    Epoch 1/20
    15000/15000 [==============================] - 2s 100us/step - loss: 0.5112 - acc: 0.7813 - val_loss: 0.3790 - val_acc: 0.8654
    Epoch 2/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.3057 - acc: 0.9003 - val_loss: 0.3029 - val_acc: 0.8884
    Epoch 3/20
    15000/15000 [==============================] - 1s 77us/step - loss: 0.2272 - acc: 0.9245 - val_loss: 0.3130 - val_acc: 0.8718
    Epoch 4/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.1874 - acc: 0.9365 - val_loss: 0.2842 - val_acc: 0.8859
    Epoch 5/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.1571 - acc: 0.9467 - val_loss: 0.2845 - val_acc: 0.8868
    Epoch 6/20
    15000/15000 [==============================] - 1s 77us/step - loss: 0.1316 - acc: 0.9587 - val_loss: 0.3343 - val_acc: 0.8692
    Epoch 7/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.1159 - acc: 0.9625 - val_loss: 0.3089 - val_acc: 0.8851
    Epoch 8/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.0993 - acc: 0.9685 - val_loss: 0.3608 - val_acc: 0.8703
    Epoch 9/20
    15000/15000 [==============================] - 1s 80us/step - loss: 0.0850 - acc: 0.9750 - val_loss: 0.3473 - val_acc: 0.8788
    Epoch 10/20
    15000/15000 [==============================] - 1s 80us/step - loss: 0.0745 - acc: 0.9781 - val_loss: 0.3719 - val_acc: 0.8757
    Epoch 11/20
    15000/15000 [==============================] - 1s 81us/step - loss: 0.0658 - acc: 0.9811 - val_loss: 0.4018 - val_acc: 0.8736
    Epoch 12/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.0566 - acc: 0.9837 - val_loss: 0.4373 - val_acc: 0.8679
    Epoch 13/20
    15000/15000 [==============================] - 1s 77us/step - loss: 0.0483 - acc: 0.9861 - val_loss: 0.4484 - val_acc: 0.8703
    Epoch 14/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.0406 - acc: 0.9897 - val_loss: 0.4728 - val_acc: 0.8677
    Epoch 15/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.0355 - acc: 0.9913 - val_loss: 0.4968 - val_acc: 0.8693
    Epoch 16/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.0301 - acc: 0.9934 - val_loss: 0.5280 - val_acc: 0.8676
    Epoch 17/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.0277 - acc: 0.9933 - val_loss: 0.5561 - val_acc: 0.8654
    Epoch 18/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.0222 - acc: 0.9949 - val_loss: 0.5822 - val_acc: 0.8654
    Epoch 19/20
    15000/15000 [==============================] - 1s 79us/step - loss: 0.0175 - acc: 0.9971 - val_loss: 0.6369 - val_acc: 0.8581
    Epoch 20/20
    15000/15000 [==============================] - 1s 78us/step - loss: 0.0152 - acc: 0.9977 - val_loss: 0.6359 - val_acc: 0.8636
    

    history对象保存了在模型训练过程的相关信息

    history_dict = history.history
    history_dict.keys()
    dict_keys(['val_loss', 'val_acc', 'loss', 'acc'])
    

    七、绘制loss和accuracy

    x轴为epochs,y轴为loss

    import matplotlib.pyplot as plt
    %matplotlib inline
    loss_values = history_dict['loss']
    val_loss_values = history_dict['val_loss']
    epochs = range(1,len(loss_values)+1)
    plt.plot(epochs,loss_values,'bo',label='Training loss')
    plt.plot(epochs,val_loss_values,'b',label='Validation loss')
    plt.title('Training and validation loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.legend()

    这里写图片描述

    x轴为epochs,y轴为accuracy

    plt.clf()
    acc_values = history_dict['acc']
    val_acc_values = history_dict['val_acc']
    
    plt.plot(epochs,acc_values,'bo',label='Training acc')
    plt.plot(epochs,val_acc_values,'b',label='Validation acc')
    plt.title('Training and validation accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Acc')
    plt.legend()

    这里写图片描述

    八、选择合适的超参数,然后在所有训练集上重新训练模型

    model.fit(x_train,
             y_train,
             epochs=4, # 由loss图发现在epochs=4的位置上validation loss最低
             batch_size=512)
    Epoch 1/4
    25000/25000 [==============================] - 1s 55us/step - loss: 0.2172 - acc: 0.9436
    Epoch 2/4
    25000/25000 [==============================] - 1s 56us/step - loss: 0.1509 - acc: 0.9552
    Epoch 3/4
    25000/25000 [==============================] - 1s 54us/step - loss: 0.1221 - acc: 0.9632
    Epoch 4/4
    25000/25000 [==============================] - 1s 54us/step - loss: 0.1012 - acc: 0.9678
    <keras.callbacks.History at 0x7f68945847b8>
    

    评估模型在测试集上的loss和accuracy

    results = model.evaluate(x_test,y_test)
    results
    [0.49199876737356185, 0.8586]
    
    展开全文
  • 导语:Science is NOT a battle, it is a collaboration. We all build on each other’s ideas. Science is an act of love, not war. Love for the beauty in the world that surrounds us and love to share and ...

    导语:Science is NOT a battle, it is a collaboration. We all build on each other’s ideas. Science is an act of love, not war. Love for the beauty in the world that surrounds us and love to share and build something together. That makes science a highly satisfying activity, emotionally speaking! ——Yoshua Bengio

    人工智能的浪潮正席卷全球,诸多词汇时刻萦绕在我们的耳边,如人工智能,机器学习,深度学习等。“人工智能”的概念早在1956年就被提出,顾名思义用计算机来构造复杂的,拥有与人类智慧同样本质特性的机器。经过几十年的发展,在2012年后,得益于数据量的上涨,运算力的提升和机器学习算法(深度学习)的出现,人工智能开始大爆发。但目前的科研工作都集中在弱人工智能部分,即让机器具备观察和感知能力,可以一定程度的理解和推理,预期在该领域能够取得一些重大突破。电影里的人工智能多半都是在描绘强人工智能,即让机器获得自适应能力,解决一些之前还没遇到过的问题,而这部分在目前的现实世界里难以真正实现。

    若人工智能有希望取得突破,是如何实现的,“智能”又从何而来呢?这主要归功于一种实现人工智能的方法——机器学习。

    一、机器学习概念

    机器学习一种实现人工智能的方法。

    机器学习最基本的做法是,使用算法来解析数据从中学习,然后对真实世界中的事件做出决策和预测。与传统的为解决特定任务、硬编码的软件程序不同,机器学习是用大量的数据来“训练”,通过各种算法从数据中学习如何完成任务。机器学习源于早期的人工智能领域,传统的算法包括决策树、聚类、贝叶斯分类、支持向量机、EM、Adaboost等等。从学习方法上来分,机器学习算法可以分为监督学习(如分类问题)、无监督学习(如聚类问题)、半监督学习、集成学习、深度学习和强化学习。

    传统的机器学习算法在指纹识别、基于Haar的人脸检测、基于HoG特征的物体检测等领域的应用基本达到了商业化的要求或者特定场景的商业化水平,但每前进一步都异常艰难,直到深度学习算法的出现。

    二、深度学习概念

    深度学习是一种实现机器学习的技术。

    其本身并不是一种独立的学习方法,也会用到有监督和无监督的学习方法来训练深度神经网络。但由于近几年该领域发展迅猛,一些特有的学习手段相继被提出(如残差网络),因此越来越多的人将其单独看作一种学习的方法。

    最初的深度学习是利用深度神经网络来解决特征表达的一种学习过程。深度神经网络本身并不是一个全新的概念,可大致理解为包含多个隐含层的神经网络结构。为了提高深层神经网络的训练效果,人们对神经元的连接方法和激活函数等方面做出相应的调整。其实有不少想法早年间也曾有过,但由于当时训练数据量不足、计算能力落后,因此最终的效果不尽如人意。深度学习,作为目前最热的机器学习方法,但并不意味着是机器学习的终点。起码目前存在以下问题:

    1、深度学习模型需要大量的训练数据,才能展现出神奇的效果,但现实生活中往往会遇到小样本问题,此时深度学习方法无法入手,传统的机器学习方法就可以处理;
    2、有些领域,采用传统的简单的机器学习方法,可以很好地解决了,没必要非得用复杂的深度学习方法;
    3、深度学习的思想,来源于人脑的启发,但绝不是人脑的模拟。

    因此,机器学习框架和深度学习框架之间也是有区别的。本质上,机器学习框架涵盖用于分类,回归,聚类,异常检测和数据准备的各种学习方法,也可以包括神经网络方法。深度学习或深度神经网络(DNN)框架涵盖具有许多隐藏层的各种神经网络拓扑,包括模式识别的多步骤过程。网络中的层越多,可以提取用于聚类和分类的特征越复杂。常见的Caffe,CNTK,DeepLearning4j,Keras,MXNet和TensorFlow是深度学习框架。 而Scikit-learning和Spark MLlib是机器学习框架。 Theano则跨越了这两个类别。

    本文接下来的篇幅将会重点介绍深度学习的三个框架caffe、tensorflow和keras,如果只是需要使用传统的机器学习基础算法使用scikit-learning和spark MLlib则更为合适。

    三、深度学习框架比较

    神经网络一般包括:训练,测试两大阶段。训练就是把训练数据和神经网络模型(AlexNet、RNN等神经网络训练框架Caffe等)用CPU或GPU提炼出模型参数的过程。测试就是把测试数据用训练好的模型(神经网络模型+模型参数)运行后查看结果。而caffe,keras,tensorflow就是把训练过程所涉及的环节数据统一抽象,形成可使用框架。

    (一)Caffe
    1、概念

    Caffe是一个清晰而高效的深度学习框架,也是一个被广泛使用的开源深度学习框架,在Tensorflow出现之前一直是深度学习领域Github star最多的项目。主要优势为:上手容易,网络结构都是以配置文件形式定义,不需要用代码设计网络。训练速度快,组件模块化,可以方便的拓展到新的模型和学习任务上。但是Caffe最开始设计时的目标只针对于图像,没有考虑文本、语音或者时间序列的数据,因此Caffe对卷积神经网络的支持非常好,但是对于时间序列RNN,LSTM等支持的不是特别充分。Caffe工程的models文件夹中常用的网络模型比较多,比如Lenet、AlexNet、ZFNet、VGGNet、GoogleNet、ResNet等。

    2、Caffe的模块结构

    Caffe由低到高依次把网络中的数据抽象成Blob, 各层网络抽象成Layer ,整个网络抽象成Net,网络模型的求解方法抽象成Solver。

    1.Blob表示网络中的数据,包括训练数据,网络各层自身的参数,网络之间传递的数据都是通过Blob来实现的,同时Blob数据也支持在CPU与GPU上存储,能够在两者之间做同步。
    2.Layer是对神经网络中各种层的抽象,包括卷积层和下采样层,还有全连接层和各种激活函数层等。同时每种Layer都实现了前向传播和反向传播,并通过Blob来传递数据。
    3.Net是对整个网络的表示,由各种Layer前后连接组合而成,也是所构建的网络模型。
    4.Solver 定义了针对Net网络模型的求解方法,记录网络的训练过程,保存网络模型参数,中断并恢复网络的训练过程。自定义Solver能够实现不同的网络求解方式。
    

    3、安装方式

    Caffe 需要预先安装比较多的依赖项,CUDA,snappy,leveldb,gflags,glog,szip,lmdb,OpenCV,hdf5,BLAS,boost、ProtoBuffer等;
    Caffe官网:http://caffe.berkeleyvision.org/;
    Caffe Github : https://github.com/BVLC/caffe;Caffe 安装教程:
    http://caffe.berkeleyvision.org/installation.html,
    http://blog.csdn.net/yhaolpz/article/details/71375762;
    Caffe 安装分为CPU和GPU版本,GPU版本需要显卡支持以及安装CUDA
    

    4、使用Caffe搭建神经网络在这里插入图片描述
    【caffe搭建神经网络流程图】
    在上述流程中,步骤2是核心操作,也是caffe使用最让人头痛的地方,keras则对该部分做了更高层的抽象,让使用者能够快速编写出自己想要实现的模型。

    (二) Tensorflow

    1、概念

    TensorFlow是一个使用数据流图进行数值计算的开源软件库。图中的节点表示数学运算,而图边表示节点之间传递的多维数据阵列(又称张量)。灵活的体系结构允许使用单个API将计算部署到服务器或移动设备中的某个或多个CPU或GPU。Tensorflow涉及相关概念解释如下:

    1)符号计算
    符号计算首先定义各种变量,然后建立一个“计算图”,图中规定了各个变量之间的计算关系。 符号计算也叫数据流图,其过程如下图2-1所示,数据是按图中黑色带箭头的线流动的。
    

    【2-1 数据流图示例】在这里插入图片描述

    数据流图用“结点”(nodes)和“线”(edges)的有向图来描述数学计算。
    ① “节点” 一般用来表示施加的数学操作,但也可以表示数据输入(feed in)的起点/输出(push out)的终点,或者是读取/写入持久变量(persistent variable)的终点。
    ② “线”表示“节点”之间的输入/输出关系。
    ③ 在线上流动的多维数据阵列被称作“张量”。
    
    2)张量
    张量(tensor),可以看作是向量、矩阵的自然推广,用来表示广泛的数据类型,张量的阶数也叫维度。
    0阶张量,即标量,是一个数。1阶张量,即向量,是一组有序排列的数。2阶张量,即矩阵,是一组向量有序的排列起来。3阶张量,即立方体,是一组矩阵上下排列起来。以此类推。
    
    3)数据格式(data_format)
    目前主要有两种方式来表示张量:
    ① th模式或channels_first模式,Theano和caffe使用此模式。
    ② tf模式或channels_last模式,TensorFlow使用此模式。
    

    举例说明两种模式的区别:对于100张RGB3通道的16×32(高为16宽为32)彩色图,th表示方式:(100,3,16,32)tf表示方式:(100,16,32,3)唯一的区别就是表示通道个数3的位置不一样。

    2、Tensorflow的模块结构

    Tensorflow/core目录包含了TF核心模块代码,具体结构如图2-2所示:
    在这里插入图片描述
    【图 2-2 tensorflow代码模块结构】
    3、安装方式

    1、官网下载naconda安装:https://www.anaconda.com/download/;
    2、依次在Anaconda Prompt控制台,按以下5个步骤输入指令进行安装:
    	1) 安装py3+ cmd : conda create -n py3.6 python=3.6 anaconda;
    	2) 激活虚拟环境 cmd : activate py3.6
    	3) 激活TSF预安装cmd: conda create -n tensorflow python=3.6;activate tensorflow;
    	4) 安装TSF:pip install —ignore-installed —upgrade tensorflow;pip install —ignore-installed —upgrade tensorflow-gpu;
    	5) 退出虚拟环境cmd :deactivate py3.6。
    

    4、使用Tensorflow搭建神经网络

    使用Tensorflow搭建神经网络主要包含以下6个步骤:
    	1) 定义添加神经层的函数;
    	2) 准备训练的数据;
    	3) 定义节点准备接收数据;
    	4) 定义神经层:隐藏层和预测层;
    	5) 定义loss表达式;
    	6) 选择optimizer使loss达到最小;
    	7) 对所有变量进行初始化,通过sess.run optimizer,迭代多次进行学习。
    

    5、示例代码

    Tensorflow 构建神经网络识别手写数字,具体代码如下所示:

    import tensorflow as tfimport numpy as np
    #添加层def add_layer(inputs, in_size, out_size, activation_function=None):
    #add one more layer and return the output of this layer
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1)
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if activation_function is None:
    	outputs = Wx_plus_b
    else:
    	outputs = activation_function(Wx_plus_b)
    return outputs
    
    #1.训练的数据
    #Make up some real data
    x_data = np.linspace(-1,1,300)[:, np.newaxis]
    noise = np.random.normal(0, 0.05, x_data.shape)
    y_data = np.square(x_data) - 0.5 + noise
    
    #2.定义节点准备接收数据
    #define placeholder for inputs to network 
    xs = tf.placeholder(tf.float32, [None, 1])
    ys = tf.placeholder(tf.float32, [None, 1])
    
    #3.定义神经层:隐藏层和预测层
    #add hidden layer 输入值是 xs,在隐藏层有 10 个神经元  
    l1 = add_layer(xs, 1, 10, activation_function=tf.nn.relu)
    #add output layer 输入值是隐藏层 l1,在预测层输出 1 个结果
    prediction = add_layer(l1, 10, 1, activation_function=None)
    
    #4.定义 loss 表达式
    #the error between prediciton and real data   
    loss = tf.reduce_mean(tf.reduce_sum(tf.square(ys - prediction),
    reduction_indices=[1]))
    
    #5.选择 optimizer 使 loss 达到最小                  
    #这一行定义了用什么方式去减少 loss,学习率是 0.1      
    train_step = tf.train.GradientDescentOptimizer(0.1).minimize(loss)
    #important step 对所有变量进行初始化
    init = tf.initialize_all_variables()
    sess = tf.Session()
    #上面定义的都没有运算,直到 sess.run 才会开始运算
    sess.run(init)
    #迭代 1000 次学习,sess.run optimizerfor i in range(1000):
    #training train_step 和 loss 都是由 placeholder 定义的运算,所以这里要用 feed 传入参数
    sess.run(train_step, feed_dict={xs: x_data, ys: y_data})
    if i % 50 == 0:
    xxx
    #to see the step improvement
    xxx
    print(sess.run(loss, feed_dict={xs: x_data, ys: y_data}))
    

    (三) Keras

    1、概念

    Keras由纯Python编写而成并基于Tensorflow、Theano以及CNTK后端,相当于Tensorflow、Theano、CNTK的上层接口,号称10行代码搭建神经网络,具有操作简单、上手容易、文档资料丰富、环境配置容易等优点,简化了神经网络构建代码编写的难度。目前封装有全连接网络、卷积神经网络、RNN和LSTM等算法。

    Keras有两种类型的模型,序贯模型(Sequential)和函数式模型(Model),函数式模型应用更为广泛,序贯模型是函数式模型的一种特殊情况。

    1. 序贯模型(Sequential):单输入单输出,一条路通到底,层与层之间只有相邻关系,没有跨层连接。这种模型编译速度快,操作也比较简单。

    2. 函数式模型(Model):多输入多输出,层与层之间任意连接。这种模型编译速度慢。

    2、Keras的模块结构

    Keras主要由5大模块构成,模块之间的关系及每个模块的功能如图3-1所示:
    在这里插入图片描述
    【图 3-1 keras模块结构图】

    3、安装方式

    Keras的安装为以下三个步骤:
    	1) 安装anaconda(python);
    	2) 用于科学计算的python发行版,支持Linux、Mac、Windows系统,提供了包管理与环境管理的功能,可以很方便的解决多版本python并存、切换以及各种第三方包安装问题;
    	3) 利用pip或者conda安装numpy、keras、 pandas、tensorflow等库;
    下载地址: https://www.anaconda.com/what-is-anaconda/。
    

    4、使用Keras搭建神经网络

    使用keras搭建一个神经网络,包括5个步骤,分别为模型选择、构建网络层、编译、训练和预测。每个步骤操作过程中使用到的keras模块如图3-2所示:
    在这里插入图片描述
    【3-2 使用keras搭建神经网络步骤】

    5、示例代码

    Kears构建神经网络识别手写数字,具体代码如下所示:
    
    from keras.models import Sequential 
    from keras.layers.core import Dense, Dropout, Activation 
    from keras.optimizers import SGD 
    from keras.datasets import mnist 
    import numpy
    
    #第一步:选择模型
    model = Sequential()
    
    #第二步:构建网络层
    model.add(Dense(500,input_shape=(784,))) # 输入层,28*28=784 
    model.add(Activation('tanh')) # 激活函数是tanh 
    model.add(Dropout(0.5)) # 采用50%的dropout
    model.add(Dense(500)) # 隐藏层节点500个 
    model.add(Activation('tanh')) 
    model.add(Dropout(0.5))
    model.add(Dense(10)) # 输出结果是10个类别,所以维度是10 
    model.add(Activation('softmax')) # 最后一层用softmax作为激活函数
    
    #第三步:编译
    sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) # 优化函数,设定学习率(lr)等参数 
    model.compile(loss='categorical_crossentropy', optimizer=sgd, class_mode='categorical') # 使用交叉熵作为loss函数
    
    '''
    #第四步:训练
    .fit的一些参数
    batch_size:对总的样本数进行分组,每组包含的样本数量
    epochs :训练次数
    shuffle:是否把数据随机打乱之后再进行训练
    validation_split:拿出百分之多少用来做交叉验证
    verbose:屏显模式 0:不输出  1:输出进度  2:输出每次的训练结果
    '''
    (X_train, y_train), (X_test, y_test) = mnist.load_data() # 使用Keras自带的mnist工具读取数据(第一次需要联网)
    
    #由于mist的输入数据维度是(num, 28, 28),这里需要把后面的维度直接拼起来变成784维 
    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1] * X_train.shape[2])
    X_test = X_test.reshape(X_test.shape[0], X_test.shape[1] * X_test.shape[2]) 
    Y_train = (numpy.arange(10) == y_train[:, None]).astype(int)
    Y_test = (numpy.arange(10) == y_test[:, None]).astype(int)
    model.fit(X_train,Y_train,batch_size=200,epochs=50,shuffle=True,verbose=0,validation_split=0.3)
    model.evaluate(X_test, Y_test, batch_size=200, verbose=0)
    
    #第五步:输出
    print("test set")
    scores = model.evaluate(X_test,Y_test,batch_size=200,verbose=0)
    print("")
    print("The test loss is %f" % scores)
    result = model.predict(X_test,batch_size=200,verbose=0)
    result_max = numpy.argmax(result, axis = 1)
    test_max = numpy.argmax(Y_test, axis = 1)
    result_bool = numpy.equal(result_max, test_max)
    true_num = numpy.sum(result_bool)
    print("")
    print("The accuracy of the model is %f" % (true_num/len(result_bool)))
    

    (四)框架优缺点对比
    在这里插入图片描述

    参考文章

    [1]. https://www.zhihu.com/question/57770020/answer/249708509 人工智能、机器学习和深度学习的区别?
    [2]. http://km.oa.com/group/25254/articles/show/325228?kmref=search&from_page=1&no=1 从入门到吃鸡—基于Caffe 框架AI图像识别自动化
    [3]. http://blog.luoyetx.com/2015/10/reading-caffe-1/
    [4]. https://zhuanlan.zhihu.com/p/24087905 Caffe入门与实践-简介
    [5]. https://keras-cn.readthedocs.io/en/latest/for_beginners/FAQ/ keras官网
    [6]. http://biog.csdn.net/sinat_26917383
    [7]. http://www.cnblogs.com/lc1217/p/7132364.html 深度学习:Keras入门(一)之基础篇
    [8]. https://www.jianshu.com/p/e112012a4b2d 一文学会用 Tensorflow 搭建神经网络
    [9]. https://www.zhihu.com/question/42061396/answer/93827994 深度学习会不会淘汰掉其他所有机器学习算法?
    [10]. https://www.leiphone.com/news/201702/T5e31Y2ZpeG1ZtaN.html TensorFlow和Caffe、MXNet、Keras等其他深度学习框架的对比
    [11]. https://chenrudan.github.io/blog/2015/11/18/comparethreeopenlib.html Caffe、TensorFlow、MXnet三个开源库对比
    [12]. https://zhuanlan.zhihu.com/p/24687814 对比深度学习十大框架:TensorFlow最流行但并不是最好
    [13]. https://www.leiphone.com/news/201704/8RWdnz9dQ0tyoexF.html 万事开头难!入门TensorFlow,这9个问题TF Boys 必须要搞清楚
    声明:本文来自腾讯Bugly,版权归作者所有。文章内容仅代表作者独立观点,不代表安全内参立场,转载目的在于传递更多信息。如需转载,请联系原作者获取授权。

    展开全文
  • Keras是一个基于Python语言编写的高度抽象与模块化的深度学习库,其最主要的优势在于对初学者友好,用户直接调用封装好的模块即可快速完成原型设计与验证。Keras的底层可以基于Tensorflow或Theano,用户可以自由选择...

    1.  Keras是什么?

    Keras是一个基于Python语言编写的高度抽象与模块化的深度学习库,其最主要的优势在于对初学者友好,用户直接调用封装好的模块即可快速完成原型设计与验证。Keras的底层可以基于Tensorflow或Theano,用户可以自由选择。另外,Keras支持在CPU和GPU之间进行无缝切换,总体而言,个人感觉这是一个相当强大的工具,并且极大地降低了AI学习与开发的门槛。

    2.  如何在Ubuntu16. 0464Bit环境下安装与配置Keras?

    这部分基本是参照官方手册,主要步骤如下:

    1)      首先,进行Ubuntu系统更新与升级。

    $sudo apt-get update

    $sudo apt-get upgrade

    2)      安装Python,Pip,Git,vim等基础开发包

    $sudo apt-get install –y python-devpython-pip python-nose git gfortran vim

    3)      安装CUDA开发环境(选配,进行GPU加速时需要,使用CPU加速可跳过这一步)

    4)      安装相关安装包

    $sudo pip install –U –pre pip setuptoolswheel

    $sudo pip install –U numpy scipymatplotlib sciket-learn scikit-image

    5)      安装theano

    sudo pip install –U –pre theano

    6)      安装keras

    sudo pip install –U –pre keras

    3.  如何用Keras快速创建深度学习网络模型并进行训练验证?

    基本步骤:

    a)       导入各种用到的模块组件,如Sequential,Dense,Dropout,Activation等模块。

    from keras.models import Sequential

    from keras.layers.core import Dense,Dropout, Activation, Flatten

    b)      创建模型

    例如创建一个简单的Sequential模型,该模型是多个网络层的线性堆叠,用户可以根据自己应用需要灵活地配置Sequential模型的内部具体结构。

    创建Sequential模型:

    model = Sequential()

    c)       配置模型

    两种方法对模型进行配置。

    第一种方法:通过向Sequential 模型传递一个各层(layer)的列表list来构造该模型。

    如:

    model= Sequential([

    Dense(32,input_dim=784),

    Activation('relu'),

    Dense(10),

    Activation('softmax'),

    ])

    可知,该模型依次由Dense层,relu非线性激活层,Dense层,SoftMax分类层构成。

    第二种方法:使用.add()方法一次添加一层到模型中。

    如:

    model.add(Dense(32,input_dim=784))

    model.add(Activation('relu')

    d)      编译模型

    在模型进行训练之前,通常使用model.compile()方法对学习过程进行配置。这里主要是设置三个参数:优化器optimizer,损失函数loss和指标列表metrics。可以使用系统预定义好的优化器和损失函数,当然也可以自己进行自定义。在解决分类问题时,指标列表metrics通常设置为metrics=['accuracy']

    #for a multi-class classification problem

    如:model.compile(optimizer='rmsprop',

    loss='categorical_crossentropy',

    metrics=['accuracy'])

    e)       训练模型

    通常使用model.fit方法,通常需要指定训练的输入数据,数据标签,训练轮数(epochs)和batchsize。

    如:

    #train the model, iterating on the data in batches

    #of 32 samples

    model.fit(data, labels, nb_epoch=10,batch_size=32)

    f)   在测试集上进行验证

    调用model.evaluate()方法,使用测试数据和标签对模型进行验证。

    model.evaluate(X_test, Y_test, batch_size=16)

    4.  一个完整的例子(使用Mnist数据集进行手写数字识别)

    '''Train a simple convnet on the MNIST dataset.
    
    Run on GPU: THEANO_FLAGS=mode=FAST_RUN,device=gpu,floatX=float32 python mnist_cnn.py
    
    Get to 99.25% test accuracy after 12 epochs (there is still a lot of margin for parameter tuning).
    16 seconds per epoch on a GRID K520 GPU.
    '''
    
    from __future__ import print_function
    import numpy as np
    np.random.seed(1337)  # for reproducibility
    
    from keras.datasets import mnist
    from keras.models import Sequential
    from keras.layers.core import Dense, Dropout, Activation, Flatten
    from keras.layers.convolutional import Convolution2D, MaxPooling2D
    from keras.utils import np_utils
    
    batch_size = 128
    nb_classes = 10
    nb_epoch = 12
    
    # input image dimensions
    img_rows, img_cols = 28, 28
    # number of convolutional filters to use
    nb_filters = 32
    # size of pooling area for max pooling
    nb_pool = 2
    # convolution kernel size
    nb_conv = 3
    
    # the data, shuffled and split between tran and test sets
    (X_train, y_train), (X_test, y_test) = mnist.load_data()
    
    X_train = X_train.reshape(X_train.shape[0], 1, img_rows, img_cols)
    X_test = X_test.reshape(X_test.shape[0], 1, img_rows, img_cols)
    X_train = X_train.astype('float32')
    X_test = X_test.astype('float32')
    X_train /= 255
    X_test /= 255
    print('X_train shape:', X_train.shape)
    print(X_train.shape[0], 'train samples')
    print(X_test.shape[0], 'test samples')
    
    # convert class vectors to binary class matrices
    Y_train = np_utils.to_categorical(y_train, nb_classes)
    Y_test = np_utils.to_categorical(y_test, nb_classes)
    
    model = Sequential()
    
    model.add(Convolution2D(nb_filters, nb_conv, nb_conv,
                            border_mode='valid',
                            input_shape=(1, img_rows, img_cols)))
    model.add(Activation('relu'))
    model.add(Convolution2D(nb_filters, nb_conv, nb_conv))
    model.add(Activation('relu'))
    model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool)))
    model.add(Dropout(0.25))
    
    model.add(Flatten())
    model.add(Dense(128))
    model.add(Activation('relu'))
    model.add(Dropout(0.5))
    model.add(Dense(nb_classes))
    model.add(Activation('softmax'))
    
    model.compile(loss='categorical_crossentropy', optimizer='adadelta')
    
    model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch,
              show_accuracy=True, verbose=1, validation_data=(X_test, Y_test))
    score = model.evaluate(X_test, Y_test, show_accuracy=True, verbose=0)
    print('Test score:', score[0])
    print('Test accuracy:', score[1])

    5.  如何切换Keras后端backend?

    创建或打开如下Keras配置文件:

    ~/.keras/keras.json

     

    默认配置如下:

    {

    “image_dim_ordering”:”tf”,

    “Epsilon”:1e-07,

    “floatx”:”float32”,

    “backend”:tensorflow”

    }

     

    将backend字段的值改为theano或者tensorflow,即可切换到相应的后端。

    6.  如何使Keras调用GPU?

    如果采用TensorFlow作为后端,当机器上有可用的GPU时,代码会自动调用GPU进行并行计算。如果使用Theano作为后端,可以通过以下方法设置:

    方法1:使用Theano标记,在执行python脚本时使用下面的命令:

    THEANO_FLAGS=device=gpu,floatX=float32python my_keras_script.py

    方法2:在代码的开头处手动设置theano.config.device 和 theano.config.floatX

    import theano

    theano.config.device= 'gpu'

    theano.config.floatX= 'float32'

     

    参考资料:《Keras中文手册》

    点击打开链接

    展开全文
  • 1.关于Keras &nbsp; &nbsp; &nbsp; &nbsp; 1)简介 &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;Keras是由纯python编写的基于...

    转载:http://www.cnblogs.com/lc1217/p/7132364.html


    1.关于Keras

            1)简介          

             Keras是由纯python编写的基于theano/tensorflow的深度学习框架。

             Keras是一个高层神经网络API,支持快速实验,能够把你的idea迅速转换为结果,如果有如下需求,可以优先选择Keras:

                    a)简易和快速的原型设计(keras具有高度模块化,极简,和可扩充特性)

                    b)支持CNN和RNN,或二者的结合

                    c)无缝CPU和GPU切换

             2)设计原则

                   a)用户友好:Keras是为人类而不是天顶星人设计的API。用户的使用体验始终是我们考虑的首要和中心内容。Keras遵循减少认知困难的最佳实践:Keras提供一致而简洁的API, 能够极大减少一般应用下用户的工作量,同时,Keras提供清晰和具有实践意义的bug反馈。

                   b)模块性:模型可理解为一个层的序列或数据的运算图,完全可配置的模块可以用最少的代价自由组合在一起。具体而言,网络层、损失函数、优化器、初始化策略、激活函数、正则化方法都是独立的模块,你可以使用它们来构建自己的模型。

                  c)易扩展性:添加新模块超级容易,只需要仿照现有的模块编写新的类或函数即可。创建新模块的便利性使得Keras更适合于先进的研究工作。

                  d)与Python协作:Keras没有单独的模型配置文件类型(作为对比,caffe有),模型由python代码描述,使其更紧凑和更易debug,并提供了扩展的便利性。

     

    2.Keras的模块结构

       

     

    3.使用Keras搭建一个神经网络

     

    4.主要概念

       1)符号计算

            Keras的底层库使用Theano或TensorFlow,这两个库也称为Keras的后端。无论是Theano还是TensorFlow,都是一个“符号式”的库。符号计算首先定义各种变量,然后建立一个“计算图”,计算图规定了各个变量之间的计算关系。

           符号计算也叫数据流图,其过程如下(gif图不好打开,所以用了静态图,数据是按图中黑色带箭头的线流动的):

            

         2)张量

              张量(tensor),可以看作是向量、矩阵的自然推广,用来表示广泛的数据类型。张量的阶数也叫维度。

              0阶张量,即标量,是一个数。

              1阶张量,即向量,一组有序排列的数

              2阶张量,即矩阵,一组向量有序的排列起来

              3阶张量,即立方体,一组矩阵上下排列起来

              4阶张量……
              依次类推

              重点:关于维度的理解

              假如有一个10长度的列表,那么我们横向看有10个数字,也可以叫做10维度,纵向看只能看到1个数字,那么就叫1维度。注意这个区别有助于理解Keras或者神经网络中计算时出现的维度问题。

        3)数据格式(data_format)

            目前主要有两种方式来表示张量:
            a) th模式或channels_first模式,Theano和caffe使用此模式。
            b)tf模式或channels_last模式,TensorFlow使用此模式。

     
            下面举例说明两种模式的区别:
             对于100张RGB3通道的16×32(高为16宽为32)彩色图,
             th表示方式:(100,3,16,32)
             tf表示方式:(100,16,32,3)
             唯一的区别就是表示通道个数3的位置不一样。

         4)模型

              Keras有两种类型的模型,序贯模型(Sequential)和函数式模型(Model),函数式模型应用更为广泛,序贯模型是函数式模型的一种特殊情况。
              a)序贯模型(Sequential):单输入单输出,一条路通到底,层与层之间只有相邻关系,没有跨层连接。这种模型编译速度快,操作也比较简单
              b)函数式模型(Model):多输入多输出,层与层之间任意连接。这种模型编译速度慢。

     

    5.第一个示例

              这里也采用介绍神经网络时常用的一个例子:手写数字的识别。

              在写代码之前,基于这个例子介绍一些概念,方便大家理解。

              PS:可能是版本差异的问题,官网中的参数和示例中的参数是不一样的,官网中给出的参数少,并且有些参数支持,有些不支持。所以此例子去掉了不支持的参数,并且只介绍本例中用到的参数。

              1)Dense(500,input_shape=(784,))

                   a)Dense层属于网络层–>常用层中的一个层

                   b) 500表示输出的维度,完整的输出表示:(*,500):即输出任意个500维的数据流。但是在参数中只写维度就可以了,比较具体输出多少个是有输入确定的。换个说法,Dense的输出其实是个N×500的矩阵。

                  c)input_shape(784,) 表示输入维度是784(28×28,后面具体介绍为什么),完整的输入表示:(*,784):即输入N个784维度的数据

             2)Activation(‘tanh’)

                  a)Activation:激活层

                  b)’tanh’ :激活函数

             3)Dropout(0.5)

                  在训练过程中每次更新参数时随机断开一定百分比(rate)的输入神经元,防止过拟合。

             4)数据集

                 数据集包括60000张28×28的训练集和10000张28×28的测试集及其对应的目标数字。如果完全按照上述数据格式表述,以tensorflow作为后端应该是(60000,28,28,3),因为示例中采用了mnist.load_data()获取数据集,所以已经判断使用了tensorflow作为后端,因此数据集就变成了(60000,28,28),那么input_shape(784,)应该是input_shape(28,28,)才对,但是在这个示例中这么写是不对的,需要转换成(60000,784),才可以。为什么需要转换呢?

               

                  如上图,训练集(60000,28,28)作为输入,就相当于一个立方体,而输入层从当前角度看就是一个平面,立方体的数据流怎么进入平面的输入层进行计算呢?所以需要进行黄色箭头所示的变换,然后才进入输入层进行后续计算。至于从28*28变换成784之后输入层如何处理,就不需要我们关心了。(喜欢钻研的同学可以去研究下源代码)。

             并且,Keras中输入多为(nb_samples, input_dim)的形式:即(样本数量,输入维度)。

            5)示例代码

    复制代码
    from keras.models import Sequential  
    from keras.layers.core import Dense, Dropout, Activation  
    from keras.optimizers import SGD  
    from keras.datasets import mnist  
    import numpy 
    '''
        第一步:选择模型
    '''
    model = Sequential()
    '''
       第二步:构建网络层
    '''
    model.add(Dense(500,input_shape=(784,))) # 输入层,28*28=784  
    model.add(Activation('tanh')) # 激活函数是tanh  
    model.add(Dropout(0.5)) # 采用50%的dropout
    
    model.add(Dense(500)) # 隐藏层节点500个  
    model.add(Activation('tanh'))  
    model.add(Dropout(0.5))
    
    model.add(Dense(10)) # 输出结果是10个类别,所以维度是10  
    model.add(Activation('softmax')) # 最后一层用softmax作为激活函数
    
    '''
       第三步:编译
    '''
    sgd = SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True) # 优化函数,设定学习率(lr)等参数  
    model.compile(loss='categorical_crossentropy', optimizer=sgd, class_mode='categorical') # 使用交叉熵作为loss函数
    
    '''
       第四步:训练
       .fit的一些参数
       batch_size:对总的样本数进行分组,每组包含的样本数量
       epochs :训练次数
       shuffle:是否把数据随机打乱之后再进行训练
       validation_split:拿出百分之多少用来做交叉验证
       verbose:屏显模式 0:不输出  1:输出进度  2:输出每次的训练结果
    '''
    (X_train, y_train), (X_test, y_test) = mnist.load_data() # 使用Keras自带的mnist工具读取数据(第一次需要联网)
    
     由于mist的输入数据维度是(num, 28, 28),这里需要把后面的维度直接拼起来变成784维 
    X_train = X_train.reshape(X_train.shape[0], X_train.shape[1] * X_train.shape[2]) 
    X_test = X_test.reshape(X_test.shape[0], X_test.shape[1] * X_test.shape[2])  
    Y_train = (numpy.arange(10) == y_train[:, None]).astype(int) 
    Y_test = (numpy.arange(10) == y_test[:, None]).astype(int)
    
    model.fit(X_train,Y_train,batch_size=200,epochs=50,shuffle=True,verbose=0,validation_split=0.3)
    model.evaluate(X_test, Y_test, batch_size=200, verbose=0)
    
    '''
        第五步:输出
    '''
    print("test set")
    scores = model.evaluate(X_test,Y_test,batch_size=200,verbose=0)
    print("")
    print("The test loss is %f" % scores)
    result = model.predict(X_test,batch_size=200,verbose=0)
    
    result_max = numpy.argmax(result, axis = 1)
    test_max = numpy.argmax(Y_test, axis = 1)
    
    result_bool = numpy.equal(result_max, test_max)
    true_num = numpy.sum(result_bool)
    print("")
    print("The accuracy of the model is %f" % (true_num/len(result_bool)))
    复制代码

     

    展开全文
  • Keras 深度学习框架

    2019-03-28 12:18:13
    https://keras.io/zh/why-use-keras/为什么选择Keras?...主流深度学习框架对比(TensorFlow、Keras、MXNet、PyTorch) 近几年来,深度学习的研究和应用的热潮持续高涨,各种开源深度学习框架层出不穷...
  • Keras是Python中以CNTK、Tensorflow或者Theano为计算后台的一个深度学习建模环境。相对于其他深度学习的计算软件,如:Tensorflow、Theano、Caffe等,Keras在实际应用中有一些显著的优点,其中最主要的优点就是Keras...
  • ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~前言今天去图书馆想找一本Tensorflow方面的教程,结果找到了这本《Tensorflow+Keras 深度学习人工智能实践应用学习 》清华大学出版社,林大贵著。目前小白一枚,打算照着这本书...
  • Keras深度学习环境配置(WIN10/GPU加速版) 本人目前在用深度学习方法做命名实体识别。起初学习阶段因为数据量不大,所以直接用CPU来训练模型;不过真正落实到研究则需要大量数据才能训练出泛化能力强的模型,这时...
  • 分享一套Keras深度学习视频教程,2019年录制,内容还很新,附带源码课件,资料齐全,希望对大家学习深度学习有所帮助!!
  • [Keras深度学习浅尝]实战二·CNN实现Fashion MNIST 数据集分类 与我们上篇博文[Keras深度学习浅尝]实战一结构相同,修改的地方有,定义网络与模型训练两部分,可以对比着来看。通过使用CNN结构,预测准确率略有提升...
  • 最近在学习深度学习,想搭建一个...现在把windows下的Anaconda+tensorflow+keras深度学习框架搭建过程记录如下 1.下载安装Anaconda记住支持版本一定是python3以上的版本 链接如下:https://www.continuum.io/downl...
  • 现在把windows下的Anaconda+tensorflow+keras深度学习框架搭建过程记录如下 1.下载安装Anaconda记住支持版本一定是python3以上的版本 链接如下:https://www.continuum.io/downloads   2.点击傻瓜式安装,下...
  • Windows环境下python中 Keras深度学习环境搭建**Windows环境下Keras搭建**基本介绍安装依赖库mingw和libpython安装依赖库 mingw安装libpython安装Theanokeras 安装 Windows环境下Keras搭建 基本介绍 Keras是一个...
  • Keras是一个用于深度学习的简单而强大的Python库。 鉴于深度学习模式可能需要数小时、数天甚至数周的时间来培训,了解如何保存并将其从磁盘中加载是很重要的。 在本文中,您将发现如何将Keras模型保存到文件中   ...
  • #1.keras深度学习框架的训练保存过程from keras.models import model_from_jsonmodel_json = model.to_json() with open("model.json", "w") as json_file: json_file.write(model_json) # serialize weights to...
  • 一、Example模型:[1 input] -> [2 neurons] -> [1 output]from keras.models import Sequential from keras.layers import Dense model = Sequential() model.add(Dense(2, input_dim=1, activation='relu')) model...
  • 为了使开发者更好的理解其开发的神经网络模型,Keras Python深度学习库提供了可视化神经网络模型的工具。这对于产品演示和讲解是非常有用的在本文,你会学到如何在Keras中总结和可视化深度学习模型。读完本文后,你...
1 2 3 4 5 ... 20
收藏数 31,056
精华内容 12,422
关键字:

keras深度学习