keras 机器学习_机器学习keras - CSDN
  • 本节使用tf.keras来训练一个神经网络模型,用于分类衣物图像(如运动鞋和衬衫),它是一个在TensorFlow中构建和训练模型的高级API。 from __future__ import absolute_import, division, print_function, unicode_...

    本节使用tf.keras来训练一个神经网络模型,用于分类衣物图像(如运动鞋和衬衫),它是一个在TensorFlow中构建和训练模型的高级API。

    from __future__ import absolute_import, division, print_function, unicode_literals
    
    # TensorFlow and tf.keras
    import tensorflow as tf
    from tensorflow import keras
    
    # Helper libraries
    import numpy as np
    import matplotlib.pyplot as plt
    
    print(tf.__version__)
    
    上述代码输出:
    2.0.0
    

    1 导入Fashion MNIST数据集

    Fashion MNIST数据集中包含10个类别的70,000张衣物的灰度图像,分辨率为28×28像素,如下图所示:

    在这里插入图片描述
    Figure 1. Fashion-MNIST samples (by Zalando, MIT License).

    Fashion MNIST数据集的目的是替代经典的MNIST数据集(这类似于编程学习里面的“Hello World”。经典的MNIST数据集包含手写数字(0、1、2等)的图像,其格式与这里使用的衣物数据集相同。

    这里,使用60,000张图像来训练网络,使用10,000张图像来评估网络图像分类网络的准确性。通过下列语句可以直接从TensorFlow访问、导入和加载Fashion MNIST数据:

    fashion_mnist = keras.datasets.fashion_mnist
    (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
    
    上述代码输出:
    Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-labels-idx1-ubyte.gz
    32768/29515 [=================================] - 0s 0us/step
    Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/train-images-idx3-ubyte.gz
    26427392/26421880 [==============================] - 0s 0us/step
    Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-labels-idx1-ubyte.gz
    8192/5148 [===============================================] - 0s 0us/step
    Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/t10k-images-idx3-ubyte.gz
    4423680/4422102 [==============================] - 0s 0us/step
    

    上述语句从TensorFlow加载数据集并返回四个NumPy数组:

    • train_images和train_labels数组是训练集:是模型用来学习的数据;
    • test_images和test_labels数组是测试集:通过测试集对模型进行测试。

    这些图像是28x28维的NumPy数组,像素值分布在0到255之间。标签(Label)是一个整数数组,范围从0到9,与图像所代表的衣物类别相对应:

    Label Class
    0 T-shirt/top
    1 Trouser
    2 Pullover
    3 Dress
    4 Coat
    5 Sandal
    6 Shirt
    7 Sneaker
    8 Bag
    9 Ankle boot

    每幅图像都对应一个标签。由于类名没有包含在数据集中,所以将它们存储在class_names中,以便后面绘制图像时使用:

    class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
                   'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
    

    2 数据细节

    在训练模型之前,让我们先研究一下数据集的格式。可以通过以下命令输出数据集的部分细节:

    train_images.shape 
    len(train_labels)
    train_labels
    test_images.shape
    len(test_labels)
    

    对应输出如下:

    (60000, 28, 28)                                  - 训练集中有60000张图像,每张图像的大小都为28x28像素
    60000                                            - 训练集中有60000个标签
    array([9, 0, 0, ..., 3, 0, 5], dtype=uint8)      - 每个标签都是0到9之间的整数
    (10000, 28, 28)                                  - 测试集中有10,000张图像。同样,每个图像表示为28 x 28像素
    10000                                            - 测试集包含10,000个图像标签
    

    3 处理数据

    在训练网络之前,必须对数据进行预处理。如果你检查训练集中的第一个图像,你会看到像素值落在0到255的范围内。可通过下列代码显示图像:

    plt.figure()
    plt.imshow(train_images[0])
    plt.colorbar()
    plt.grid(False)
    plt.show()
    

    得到下图:

    在这里插入图片描述

    在将这些值输入神经网络模型之前,需要将训练集和测试集中图像的像素值缩放到0到1的范围。可通过以下代码实现:

    train_images = train_images / 255.0
    test_images = test_images / 255.0
    

    为了验证数据的格式是否正确,我们通过以下代码显示来自训练集的前25个图像,并在每个图像下面显示类名:

    plt.figure(figsize=(10,10))
    for i in range(25):
        plt.subplot(5,5,i+1)
        plt.xticks([])
        plt.yticks([])
        plt.grid(False)
        plt.imshow(train_images[i], cmap=plt.cm.binary)
        plt.xlabel(class_names[train_labels[i]])
    plt.show()
    

    在这里插入图片描述

    4 构建(配置)模型

    建立神经网络需要配置模型的层,然后编译模型,下面分别实现。

    4.1 设置模型的层(layer)

    layer是神经网络的基本组件,它从输入的数据中提取数据的特征表示。

    大多数深度学习是由简单的layer链接在一起构成的。大多数layer(如tf.keras.layers.Dense),包含有在训练中学习的参数。我们使用以下代码构建本节的模型:

    model = keras.Sequential([
        keras.layers.Flatten(input_shape=(28, 28)),
        keras.layers.Dense(128, activation='relu'),
        keras.layers.Dense(10, activation='softmax')
    ])
    
    • tf.keras.layers.Flatten:这是网络的第一层,将图像的格式从一个二维数组(28×28像素)转换为一个一维数组(28 * 28 = 784像素)。可以把这个层看作是将图像中的像素行分解并排列起来。这一层没有需要学习的参数,它只是重新格式化数据。
    • 当像素被格式化后,网络由两个tf.keras.layers.Dense组成的序列组成。这些layer紧密相连,或者说完全相连:
      • 第一个Dense层有128个节点(或神经元);
      • 第二个Dense层(也即最后一层)是一个有10个节点的softmax层,它返回一个10个概率值的数组,这些概率值的和为1。每个节点包含一个分数,表示当前图像属于10个类之一的概率。

    4.2 编译模型

    在对模型进行训练之前,需要额外设置一些参数。这些是在模型的编译步骤中添加的:

    • 损失函数(Loss function):用来衡量训练过程中模型的准确性,模型训练时通过最小化这个函数来”引导“模型朝正确的方向前进;
    • 优化器(Optimizer):是模型根据数据和损失函数进行更新的方式;
    • 度量(Metrics):用于监视训练和测试步骤。下面的例子使用accuracy度量,即被正确分类的图像的比例。
    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])
    

    5 训练模型

    训练神经网络模型需要以下步骤:

    1. 将训练数据输入模型。在本例中,训练数据存放在train_images和train_tags数组中;
    2. 模型通过学习把图像和标签联系起来;
    3. 让模型对本例中的测试集test_images数组进行预测。验证预测是否与test_labels数组中的标签匹配。

    要开始训练,使用model.fit方法:

    model.fit(train_images, train_labels, epochs=10)
    

    输出如下:

    Train on 60000 samples
    Epoch 1/10
    60000/60000 [==============================] - 5s 85us/sample - loss: 0.4978 - accuracy: 0.8245
    Epoch 2/10
    60000/60000 [==============================] - 4s 69us/sample - loss: 0.3798 - accuracy: 0.8624
    Epoch 3/10
    60000/60000 [==============================] - 4s 62us/sample - loss: 0.3411 - accuracy: 0.8762
    Epoch 4/10
    60000/60000 [==============================] - 4s 61us/sample - loss: 0.3164 - accuracy: 0.8838
    Epoch 5/10
    60000/60000 [==============================] - 4s 61us/sample - loss: 0.2956 - accuracy: 0.8902
    Epoch 6/10
    60000/60000 [==============================] - 4s 64us/sample - loss: 0.2815 - accuracy: 0.8955
    Epoch 7/10
    60000/60000 [==============================] - 4s 65us/sample - loss: 0.2691 - accuracy: 0.9009
    Epoch 8/10
    60000/60000 [==============================] - 4s 62us/sample - loss: 0.2579 - accuracy: 0.9029
    Epoch 9/10
    60000/60000 [==============================] - 4s 63us/sample - loss: 0.2485 - accuracy: 0.9062
    Epoch 10/10
    60000/60000 [==============================] - 4s 60us/sample - loss: 0.2388 - accuracy: 0.9100
    
    <tensorflow.python.keras.callbacks.History at 0x7fefe642a860>
    

    当模型训练时,会输出显示损失(loss)和精度(accuracy)度量指标。该模型的精度约为0.91(或91%)。

    6 评估模型精度

    接下来,比较模型在测试数据集上的执行情况:

    test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
    print('\nTest accuracy:', test_acc)
    

    输出如下:

    10000/1 - 1s - loss: 0.2934 - accuracy: 0.8830
    Test accuracy: 0.883
    

    结果表明,测试数据集的准确性略低于训练数据集的准确性。这种训练精度和测试精度之间的差距表示过拟合。过拟合是指机器学习模型在新的、以前未见过的输入上的表现不如在训练数据上的表现。

    7 模型预测

    通过训练模型,可以使用它对一些图像进行预测:

    predictions = model.predict(test_images)
    

    这里,模型已经预测了测试集中每张图片的标签,让我们看一下第一个预测:

    predictions[0]
    

    输出如下:

    array([1.06123218e-06, 8.76374884e-09, 4.13958730e-07, 9.93547733e-09,
       2.39135318e-07, 2.61428091e-03, 2.91701099e-07, 6.94991834e-03,
       1.02351805e-07, 9.90433693e-01], dtype=float32)
    

    预测结果是一个由10个数字组成的数组。它们代表了模特的“置信度(confidence)”,即图像对应于10件不同的衣服中的每一件。你可以看到哪个标签的置信度最高:

    np.argmax(predictions[0])
    

    输出为:

    9
    

    因此,模型最确信这是一个Ankle boot,或class_names[9]。

    我们将这张图绘制出来查看完整的10个类预测的置信度,下面定义2个函数用于绘制数据图像:

    def plot_image(i, predictions_array, true_label, img):
      predictions_array, true_label, img = predictions_array, true_label[i], img[i]
      plt.grid(False)
      plt.xticks([])
      plt.yticks([])
    
      plt.imshow(img, cmap=plt.cm.binary)
    
      predicted_label = np.argmax(predictions_array)
      if predicted_label == true_label:
        color = 'blue'
      else:
        color = 'red'
    
      plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                    100*np.max(predictions_array),
                                    class_names[true_label]),
                                    color=color)
    
    def plot_value_array(i, predictions_array, true_label):
      predictions_array, true_label = predictions_array, true_label[i]
      plt.grid(False)
      plt.xticks(range(10))
      plt.yticks([])
      thisplot = plt.bar(range(10), predictions_array, color="#777777")
      plt.ylim([0, 1])
      predicted_label = np.argmax(predictions_array)
    
      thisplot[predicted_label].set_color('red')
      thisplot[true_label].set_color('blue')
    

    让我们看看第0张图片、预测和预测数组。正确的预测标签是蓝色的,错误的预测标签是红色的。这个数字给出了预测标签的百分比(满分100)。调用前面定义的函数来绘制数据图:

    i = 0
    plt.figure(figsize=(6,3))
    plt.subplot(1,2,1)
    plot_image(i, predictions[i], test_labels, test_images)
    plt.subplot(1,2,2)
    plot_value_array(i, predictions[i],  test_labels)
    plt.show()
    

    在这里插入图片描述

    i = 12
    plt.figure(figsize=(6,3))
    plt.subplot(1,2,1)
    plot_image(i, predictions[i], test_labels, test_images)
    plt.subplot(1,2,2)
    plot_value_array(i, predictions[i],  test_labels)
    plt.show()
    

    在这里插入图片描述
    让我们用他们的预测来绘制几幅图像。需要注意的是,即使在置信度非常高的情况下,模型也可能出错。

    # Plot the first X test images, their predicted labels, and the true labels.
    # Color correct predictions in blue and incorrect predictions in red.
    num_rows = 5
    num_cols = 3
    num_images = num_rows*num_cols
    plt.figure(figsize=(2*2*num_cols, 2*num_rows))
    for i in range(num_images):
      plt.subplot(num_rows, 2*num_cols, 2*i+1)
      plot_image(i, predictions[i], test_labels, test_images)
      plt.subplot(num_rows, 2*num_cols, 2*i+2)
      plot_value_array(i, predictions[i], test_labels)
    plt.tight_layout()
    plt.show()
    

    在这里插入图片描述
    最后,利用训练后的模型对单个图像进行预测。

    # Grab an image from the test dataset.
    img = test_images[1]
    print(img.shape)
    

    输出如下:

    (28, 28)
    

    tf.keras模型经过优化,可以一次对一批或一组示例进行预测。因此,即使你使用的是一张图片,你也需要将它添加到一个列表中:

    # Add the image to a batch where it's the only member.
    img = (np.expand_dims(img,0))
    print(img.shape)
    

    输出如下:

    (1, 28, 28)
    

    现在预测这个图像的正确标签:

    predictions_single = model.predict(img)
    print(predictions_single)
    

    输出如下:

    [[1.4175281e-04 8.5218921e-14 9.9798274e-01 1.7262291e-11 1.3707496e-03
      1.4081123e-14 5.0472573e-04 6.2876434e-17 3.6248435e-09 1.8519042e-13]]
    
    plot_value_array(1, predictions_single[0], test_labels)
    _ = plt.xticks(range(10), class_names, rotation=45)
    

    在这里插入图片描述
    model.predict返回一个对批量数据中每个图像的列表。获取预测我们的(唯一的)图像块(batch):

    np.argmax(predictions_single[0])
    

    输出如下:

    2
    
    展开全文
  • 机器学习——Keras

    2019-09-02 23:41:59
    Keras 是一个python深度学习框架,可以方便定义和训练几乎所有类型的深度学习模型 Keras 最开始是为研究人员 开发的,目的是为了能够快速实验 Keras 的重要特性 相同 的代码可以在CPU 和 GPU上无缝的切...

    Keras基本概念

    Keras —— 简洁高效的深度神经网络工具
    Keras 是一个python深度学习框架,可以方便定义和训练几乎所有类型的深度学习模型
    Keras 最开始是为研究人员 开发的,目的是为了能够快速实验

    Keras 的重要特性

    1. 相同 的代码可以在CPU 和 GPU上无缝的切换运行
    2. 具有友好的api ,便于快速开发深度学习模型的原理
    3. 内置支持卷积网络(用于机器视觉),循环网络(用于序列处理) 以及二者的任意组合
    4. 支持任意架构网络,多输入或者多层输出模型,层共享,模型共享,也就是说,Keras能构建任意深度学习模型
    5. Keras 基于宽松的MIT许可认证办法,在商业项目中可以免费使用,并且所有python版本都兼容

    Keras 架构

    Keras是一个模型级(model—level)的库,为开发深度学习模块提供了高层次的构建模型。
    Keras是依赖于一个专门的,高度优化的张量库来完成运算,这个张量库就是Keras的后端引擎。目前Keras有三个后端实现: Tensorflow,Theano ,和微软认知工具包
    在这里插入图片描述

    Keras工作流

    (1)定义训练数据: 输入张量和目标张量
    (2)定义层组成的网络(或者模型),将输入映射到目标
    (3)配置学习过程:选择损失函数,优化器和需要监控的指标
    (4)调用模型的fit方法在训练数据上进行迭代

    定义模型的方法
    (1)使用Sequential类(仅用于层的线性堆叠,这是目前最常见的网络构架)
    在这里插入图片描述
    (2)函数式API 用于层组成的 有向无环图,可以构建任意形式的架构
    在这里插入图片描述

    Keras的编译和训练

    Keras的编译: 编译也就是配置学习过程,可以指定模型使用的优化器和损失函数以及训练过程中想要监控的指标
    在这里插入图片描述

    Keras的训练
    通过fit() 方法将输入数据的numpy数组(和对应的目标数据)传入模型,这个做法和Stick—learn 及其他机器学习库类似
    在这里插入图片描述

    展开全文
  • 目录 简单示例 数据获取 数据预处理 序列填充Sequence Padding One-Hot Encoding: 常用于类别标签的转换 模型结构 序列模型 Sequential Model Multilayer Perceptron...卷积网络Convolutional Neural Netwo...

    目录

    简单示例

    数据获取

    数据预处理

    序列填充Sequence Padding

     One-Hot Encoding: 常用于类别标签的转换

    模型结构

    序列模型 Sequential Model

    Multilayer Perceptron (MLP)

    二分类 Binary Classification

    多分类

    回归

    卷积网络Convolutional Neural Network (CNN)

    循环神经网络RNN

    划分数据集为训练/测试

    数据标准化Standardization / Normalization

     查看模型的配置 Inspect Model

    模型的编译 Compile Model

    模型的训练fit

    模型的性能评估evaluate

    模型的预测结果

    模型的保存& 加载    Save/ Reload

    模型的精调Model Fine-tuning

    最优化参数

    提前终止 Early Stopping



    简单示例

     import numpy as np 
    from keras.models import Sequential
    from keras.layers import Dense 
    
    data = np.random.random((1000,100))   # 数据特征
    labels = np.random.randint(2,size=(1000,1))  #标签
    model = Sequential()     # 序列化模型
    model.add(Dense(32,activation='relu',input_dim=100)) # 添加一个全连接层,有32个神经元,激活函数为relu,输入的维度等于data的列数
    model.add(Dense(1, activation='sigmoid'))  #添加一个全连接层,作为输出层,用一个sigmoid输出预测的类别概率值
    model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])  # 模型编译,以便于训练
    model.fit(data,labels,epochs=10,batch_size=32)  # 模型的训练/拟合,传入数据和标签,训练10轮,批量大小为32
    predictions = model.predict(data)  # 对data预测其label 

    数据获取

    '''导入常用的机器学习数据集'''
    from keras.datasets import boston_housing, mnist, cifar10,  imdb
    (x_train,y_train),(x_test,y_test) = mnist.load_data()   # 数字手写体图片数据集
    (x_train2,y_train2),(x_test2,y_test2) = boston_housing.load_data()   # 波士顿房价数据集
    (x_train3,y_train3),(x_test3,y_test3) = cifar10.load_data()     # cifar图片数据集
    (x_train4,y_train4),(x_test4,y_test4) = imdb.load_data(num_words=20000)   # imdb影评数据集
    num_classes = 10  # 类别数
    
    # 其它方式:爬虫
    from urllib.request import urlopen 
    data = np.loadtxt(urlopen("http://archive.ics.uci.edu/ ml/machine-learning-databases/pima-indians-diabetes/ pima-indians-diabetes.data"),delimiter=",")  # 爬取糖尿病数据集
    X = data[:,0:8] 
    y = data [:,8]

    数据预处理

    padding 和 one-hot 操作经常会共同出现

    序列填充Sequence Padding

    from keras.preprocessing import sequence 
    x_train4 = sequence.pad_sequences(x_train4,maxlen=80)
    x_test4 = sequence.pad_sequences(x_test4,maxlen=80) 

     

     One-Hot Encoding: 常用于类别标签的转换

    '''将整型标签转为onehot。y为int数组,num_classes为标签类别总数,大于max(y)(标签从0开始的)。'''
    from keras.utils import to_categorical 
    Y_train = to_categorical(y_train, num_classes) 
    Y_test = to_categorical(y_test, num_classes) 
    Y_train3 = to_categorical(y_train3, num_classes) 
    Y_test3 = to_categorical(y_test3, num_classes)
    

    模型结构

    序列模型 Sequential Model

    from keras.models import Sequential
    model = Sequential()
    model2 = Sequential() 
    model3 = Sequential() 

    Multilayer Perceptron (MLP)

    二分类 Binary Classification

    ''' 二分类的输出层用activation='sigmoid  '''
    from keras.layers import Dense  
    model.add(Dense(12, input_dim=8,kernel_initializer='uniform', activation='relu'))
    model.add(Dense(8,kernel_initializer='uniform',activation='relu')) 
    model.add(Dense(1,kernel_initializer='uniform',activation='sigmoid'))
    
    

    多分类

    '''  多个类别的最后一层用activation='softmax''''
    from keras.layers import Dropout  
    model.add(Dense(512,activation='relu',input_shape=(784,))) 
    model.add(Dropout(0.2))
    model.add(Dense(512,activation='relu')) 
    model.add(Dropout(0.2)) 
    model.add(Dense(10,activation='softmax'))
    

    回归

    '''    回归问题输出的是一个数值,最后一层用一个神经元   '''
    model.add(Dense(64,activation='relu',input_dim=train_data.shape[1])) 
    model.add(Dense(1))

    卷积网络Convolutional Neural Network (CNN)

    from keras.layers import Activation,Conv2D,MaxPooling2D,Flatten 
    ''' Conv2D二维卷积 ,可以写多个像下面这样的层,再拍平Flatten'''
    model2.add(Conv2D(32,(3,3),padding='same',input_shape=x_train.shape[1:])) 
    model2.add(Activation('relu')) 
    model2.add(MaxPooling2D(pool_size=(2,2)))   # 最大池化
    model2.add(Dropout(0.25)) 
    
    model2.add(Flatten()) 
    model2.add(Dense(512))  # 全连接层,靠近输出的全连接层通常要Dropout,
    model2.add(Activation('relu')) 
    model2.add(Dropout(0.5)) 
    model2.add(Dense(num_classes))   # 输出层,的神经元数目等于类别数,用softmax激活函数
    model2.add(Activation('softmax')) 

    循环神经网络RNN

    from keras.klayers import Embedding,LSTM 
    model3.add(Embedding(20000,128))   # RNN常用于处理序列问题,文本处理就属于序列问题,通常需要词嵌入Embedding
    model3.add(LSTM(128,dropout=0.2,recurrent_dropout=0.2))   # 使用LSTM单元
    model3.add(Dense(1,activation='sigmoid'))  

    划分数据集为训练/测试

    '''训练集/验证集划分的模块train_test_split  '''
    from sklearn.model_selection import train_test_split 
    X_train5,X_test5,y_train5,y_test5 = train_test_split(X, y, test_size=0.33, random_state=42)                                                     

    数据标准化Standardization / Normalization

    from sklearn.preprocessing import StandardScaler 
    scaler = StandardScaler().fit(x_train2) 
    standardized_X = scaler.transform(x_train2) 
    standardized_X_test = scaler.transform(x_test2)
    

     查看模型的配置 Inspect Model

    model.output_shape      # 模型输出的维度  Model output shape 
    model.summary()         #   Model summary representation         
    model.get_config()      #  模型配置信息  Model configuration 
    model.get_weights()     #列出模型中所有的张量权重   List all weight tensors in the model
    

    模型的编译 Compile Model

    ''' MLP: Binary Classification 二分类的损失用二分类的交叉熵binary_crossentropy'''
    model.compile(optimizer='adam', loss='binary_crossentropy',  metrics=['accuracy'])  
    
    ''' MLP: Multi-Class Classification,多元分类的损失categorical_crossentropy,用精度accuracy来评价模型'''
    model.compile(optimizer='rmsprop', loss='categorical_crossentropy',  metrics=['accuracy'])
    
    '''  MLP: Regression 回归问题用mse均方误差,mae是平均绝对偏差 '''
    model.compile(optimizer='rmsprop',loss='mse',  metrics=['mae']) 
    
    '''Recurrent Neural Network '''
    model3.compile(loss='binary_crossentropy', optimizer='adam',  metrics=['accuracy']) 

     

    模型的训练fit

    model3.fit(x_train4, y_train4,  batch_size=32, epochs=15, verbose=1, validation_data=(x_test4,y_test4)) 

    模型的性能评估evaluate

    #Evaluate Your Model's Performance 
    score = model3.evaluate(x_test,y_test, batch_size=32)

    模型的预测结果

     Prediction
    model3.predict(x_test4, batch_size=32) 
    model3.predict_classes(x_test4,batch_size=32)  # 预测类别predict_classes

    模型的保存& 加载    Save/ Reload

    from keras.models import load_model 
    model3.save('model_file.h5')   # 保存,save里写保存的path路径
    my_model = load_model('my_model.h5')  # 加载

    模型的精调Model Fine-tuning

    最优化参数

    #  Optimization Parameters
    from keras.optimizers import RMSprop 
    opt = RMSprop(lr=0.0001, decay=1e-6) 
    model2.compile(loss='categorical_crossentropy', optimizer=opt,  metrics=['accuracy'])

    提前终止 Early Stopping

    from keras.callbacks import EarlyStopping 
    early_stopping_monitor = EarlyStopping(patience=2)
    model3.fit(x_train4,  y_train4, batch_size=32,  epochs=15,  validation_data=(x_test4,y_test4),             callbacks=[early_stopping_monitor])
     
    展开全文
  • 机器学习的四个分支 1. 监督学习 (supervised learning) 给定一组样本(通常人工标注),它可以学会将输入数据映射到已知目标(也叫标注 annotation)。三种类型的机器学习问题:二分类问题、多分类问题和标量...

    一. 机器学习的四个分支

    1. 监督学习 (supervised learning)

           给定一组样本(通常人工标注),它可以学会将输入数据映射到已知目标(也叫标注 annotation)。三种类型的机器学习问题:二分类问题、多分类问题和标量回归问题都是监督学习。比如:光学字符识别、语音识别、图像分类和语言翻译。

             虽然监督学习主要包括分类和回归,但有更多的奇特变体,主要包括如下几种:

             A. 序列生成(sequence generation) : 给定一张图像,预测描述图像的文字。序列生成有时 可以被重新表示为一系列分类问题,比如反复预测序列中的单词或标记。

            B. 语法树预测(syntax tree prediction) : 给定一个句子,预测其分解生成的语法树。

            C. 目标检测(object detection) : 给定一张图像,在图中特定目标的周围画一个边界框。这 个问题也可以表示为分类问题(给定多个候选边界框,对每个框内的目标进行分类)或分类与回归联合问题(用向量回归来预测边界框的坐标)。

            D. 图像分割(image segmentation) : 给定一张图像,在特定物体上画一个像素级的掩模(mask)。

     

    2. 无监督学习 (unsupervised learning)

           指在没有目标的情况下寻找输入数据的有趣变换,其目的在于数据可视化、数据压缩、数据去燥或更好地理解数据中的相关性。无监督学习是数据分析的必备技能,在解 决监督学习问题之前,为了更好地了解数据集,它通常是一个必要步骤。降维(dimensionality reduction)和聚类(clustering)都是众所周知的无监督学习方法。

     

    3. 自监督学习 (Self-supervised learning)

            自监督学习是没有 人工标注的标签的监督学习,可以将它看作没有人类参与的监督学习。标签仍然存在(因为总要有什么东西来监督学习过程),但它们是从输入数据中生成的,通常是使用启发式算法生成的。典型例子:

            1. 自编码器(autoencoder)是有名的自监督学习的例子,其生成的目标就是未经 修改的输入。

            2. 给定视频中过去的帧来预测下一帧,或者给定文本中前面的词来预测下一个词, 都是自监督学习的例子[这两个例子也属于时序监督学习(temporally supervised learning),即用未来的输入数据作为监督]

     

    4. 强化学习 (Reinforcement learning)

             在强化学习中,智能体(agent)接收有关其环境的信息,并学会选择使某种奖励最大化的行动。 例如,神经网络会“观察”视频游戏的屏幕并输出游戏操作,目的是尽可能得高分,这种神经 网络可以通过强化学习来训练。

             目前,强化学习主要集中在研究领域,除游戏外还没有取得实践上的重大成功。但是,我 们期待强化学习未来能够实现越来越多的实际应用:自动驾驶汽车、机器人、资源管理、教育等。 强化学习的时代已经到来,或即将到来。

     

    二. 评估机器学习模型

              机器学习的目的是得到可以泛化(generalize)的模型,而过拟合则是核心难点。我们会将数据划分为 训练集、验证集和测试集

    1. 为什么不是2个集合:一个训练集和一个测试集?

             原因在于开发模型时总是需要调节模型配置,比如选择层数或每层大小[这叫作模型的超 参数(hyperparameter)以便与模型参数(即权重)区分开]。这个调节过程需要使用模型在验证数据上的性能作为反馈信号。这个调节过程本质上就是一种学习:在某个参数空间中寻找良好的模型配置。因此,如果基于模型在验证集上的性能来调节模型配置,会很快导致模型在验证集上过拟合,即使你并没有在验证集上直接训练模型也会如此。

             造成这一现象的关键在于信息泄露(information leak)。每次基于模型在验证集上的性能来调节模型超参数,都会有一些关于验证数据的信息泄露到模型中。如果对每个参数只调节一次, 那么泄露的信息很少,验证集仍然可以可靠地评估模型。但如果你多次重复这一过程(运行一 次实验,在验证集上评估然后据此修改模型),那么将会有越来越多的关于验证集的信息泄漏到模型中。

            最后,你得到的模型在验证集上的性能非常好(人为造成的),因为这正是你优化的目的。 你关心的是模型在全新数据上的性能,而不是在验证数据上的性能,因此你需要使用一个完全不同的、前所未见的数据集来评估模型,它就是测试集。你的模型一定不能读取与测试集有关的任何信息,既使间接读取也不行。如果基于测试集性能来调节模型,那么对泛化能力的衡量 是不准确的。

    1. 那么如果数据量很小,如何评估???介绍三种典型的评估方法:

    1. 简单的留出验证 (Simple Hold-out validation) :

             留出一定比例的数据作为测试集,在剩余的数据上训练模型,然后在测试集少评估模型。

             缺点:如果可用的数据很少,那么可能验证集和测试集包含的样本就很少,从而无法在统计学上代表数据。这个很容易发现,如果在划分数据前进行不同的随机打乱( shuffle(data)) ,最终得到的模型性能差别很大。

    2. K折验证(K-fold validation)

             将数据划分为大小相同的K个分区。对于每个分区i,在剩余的K-1 个分区上训练模型,然后在分区i上评估模型。最终分数风雨K个分数的平均值。对于不同的训练集-测试集划分,如果模型性能的变化很大,那么这种方法很有用。K折验证也需要独立的验证集进行模型校正。3折验证如下:

    3.带打乱数据的 K折验证(Iterated K-fold validation with shuffle)

             具体做法是多次使用 K 折验证,在每次将数据划分为 K 个分区之前都先将数据打乱。最终分数是每次 K 折验证分数的平均值。注意,这种方法一共要训练和评估 P×K 个模型(P 是重复次数),计算代价很大。K一般取值45

    1. 评估模型的注意事项

    1. 数据代表性(data representativeness):在将数据划分为训练集和测试集之前,通常应该随机打乱/Shuffle数据

    2. 时间箭头(the arrow of time:  如果想要根据过去预测未来(比如明天的天气、股票走势 等),那么在划分数据前你不应该随机打乱数据,因为这么做会造成时间泄露(temporal leak): 你的模型将在未来数据上得到有效训练。在这种情况下,你应该始终确保测试集中所有数据的时间都晚于训练集数据

    3. 数据冗余(redundancy:  如果数据中的某些数据点出现了两次(这在现实中 的数据里十分常见),那么打乱数据并划分成训练集和验证集会导致训练集和验证集之 间的数据冗余。从效果上来看,你是在部分训练数据上评估模型,这是极其糟糕的!一定要确保训练集和验证集之间没有交集

     

    三. 数据预处理 & 特征工程

    A. 数据预处理Data preprocessing

             1. 向量化 Vectorization:神经网络的所有输入和目标都必须是浮点数张量(在特定情况下可以是整数张量)。无论处理什么数据(声音、图像还是文本),都必须首先将其转换为张量。方法:One-hot编码和填充列表

             2. 值标准化 Value Normalization:一般来说,将取值相对较大的数据(比如多位整数,比网络权重的初始值大很多)或异质数据(heterogeneous data,比如数据的一个特征在 0~1 范围,另一个特征在 100~200 范围) 输入到神经网络中是不安全的。这么做可能导致较大的梯度更新,会导致网络无法收敛。为 了让网络的学习变得更容易,输入数据应具有的特征:

              3. 处理缺失值 Handling Missing Value:一般来说,对于神经网络,将缺失值设置为 0 是安全的,只要 0 不是一个有意义的值。网络能够从数据中学到 0 意味着缺失数据,并且会忽略这个值。

             【注意】如果测试数据中可能有缺失值,而网络是在没有缺失值的数据上训练的,那么网络不可能学会忽略缺失值。在这种情况下,应该人为生成一些有缺失项的训练样本:  多次复制 一些训练样本,然后删除测试数据中可能缺失的某些特征。

     

    B. 特征工程 Feature Engineering

             特征工程(feature engineering)是指将数据输入模型之前,利用关于数据和机器学习算法(如神经网络)的知识对数据进行硬编码的变换(不是模型学到的),以改善模型的效果。多数情况下,一个机器学习模型无法从完全任意的数据中进行学习。呈现给模型的数据应该便于模型进行学习

             其本质是:用更简单的方式表述问题,从而使问题变得更容器。将数据呈现给算法的方式对解决问题至关重要。对于现代深度学习,大部分特征工程都是不需要的,因为神经网络能够从原始数据中自动提取有用的特征。为什么使用DL就不需要担心特征工程???

             1.良好的特征仍然可以用更少的资源更优雅地解决问题。例如,使用卷积神经网络来读取钟面上的时间是非常可笑的。

             2.良好的特征可以用更少的数据解决问题。深度学习模型自主学习特征的能力依赖于大量的训练数据。如果只有很少的样本,那么特征的信息价值就变得非常重要。

            

     四. 过拟合Overfitting & 欠拟合Underfitting

             机器学习的根本问题是优化和泛化之间的对立优化(optimization)是指调节模型以在训练数据上得到最佳性能(即机器学习中的学习),而泛化(generalization)是指训练好的模型在前所未见的数据上的性能好坏。机器学习的目的当然是得到良好的泛化,但泛化无法控制只能基于训练数据调节模型。

             过拟合:随着训练的进行,模型在训练数据上的性能始终在提高,但在前所未见的数据上的性能则不再变化或者开始下降。也就是说训练的太过了,把一些无关的、非重要的特征也训练出来了。

             欠拟合:训练数据上的损失越小,测试数据上的损失也越小。即仍有改进的空间,网络还没有对训练数据中所有相关模式建模。也就是说训练数据中还有一些有价值的特征没有训练出来。

    ~~~~~~~防止神经网络过拟合Overfitting的常用方法~~~~~

             1.获取更多的训练数据(最优解)

             2. 减小网络容量(最简单的方法)

             3. 添加权重正则化(最常见的方法)---L1正则化和L2正则化

             4.添加dropout正则化(最有效并且最常用的方法)

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    详细介绍:

    1.减小网络大小--reduce the network’s size

             防止过拟合的最简单的方法就是减小模型大小,即减少模型中可学习参数的个数(这由层数和每层的单元个数决定 Hyperparameter。在深度学习中,模型中可学习参数的个数通常被称为模型的容量 (capacity)。直观上来看,参数更多的模型拥有更大的记忆容量(memorization capacity),因此能够在训练样本和目标之间轻松地学会完美的字典式映射,这种映射没有任何泛化能力。

             没有一个魔法公式能够确定最佳层数或每层的最佳大小。必须评估一系列不同的网络架构(当然是在验证集上评估,而不是在测试集上),以便为数据找到最佳的模型大小(即在容量过大与容量不足之间要找到一个折中)。一般的工作流程是开始时选择相对较少的层和参数,然后逐渐增加层的大小或增加新层,直到这种增加对验证损失的影响变得很小

              更大网络的训练损失很快就接近于零。网络的容量越大,它拟合训练数据(即得到很小的训练损失)的速度就越快,但也更容易过拟合(导致训练损失和验证损失有很大差异)。

     

    2.添加权重正则化—add weight regularization

             奥卡姆剃刀(Occam’s razor):如果一件事情有两种解释,那么最可能正确的解释就是最简单的那个,即假设更小的那个(为啥想起了墨菲定律?!)。给定一些训练数据和一种网络架构,很多组权重值(即很多模型)都可以解释这些数据,简单模型比复杂模型更不容易过拟合

              简单的模型:是指参数值分布的熵(entropy)更小的模型(或参数更少的模型)。一种常见的降低过拟合的方法就是强制让模型权重只能取较小的值, 从而限制模型的复杂度,这使得权重值的分布更加规则(regular),即权重正则化(weight regularization)其实现方法是向网络损失函数中添加与较大权重值相关的成本(cost)。 这个成本有两种形式。

              1. L1 正则化(L1 regularization): 添加的成本与权重系数的绝对值[权重的 L1 范数(norm)] 成正比。

              2. L2 正则化(L2 regularization): 添加的成本与权重系数的平方(权重的 L2 范数)成正比。 神经网络的 L2 正则化也叫权重衰减(weight decay)

              form keras import regularizers

              regularizers.l1(0.001)

              regularizers.l1_l2(l1 = 0.001, l2 = 0.001)

              L2(0.001)的意思是该层权重矩阵的每个系数都会使网络总损失增加0.001 * weight_ coefficient_value。

     

    3.添加dropout正则化—add  dropout  regularization

            对某一层使用 dropout,就是在训练过程中随机将该层的一些输出特征舍弃(设置为 0)。假设在训练过程中,某一层对给定输入样本的返回值应该是向量 [0.2, 0.5, 1.3, 0.8, 1.1]。使用 dropout 后,这个向量会有几个随机的元素变成 0,比如 [0, 0.5, 1.3, 0, 1.1]。dropout 比率(dropout rate)是被设为 0 的特征所占的比例,通常在 0.2~0.5 范围内。测试时没有单元被舍弃,而该层的输出值需要按 dropout 比率缩小,因为这时比训练时有更多的单元被激活,需要加以平衡。

            题外话:为什么能降低过拟合???灵感来自于银行的防欺诈机制。其核心思想是在层的输出值中引入噪声, 打破不显著的偶然模式(Hinton 称之为阴谋)。如果没有噪声的话,网络将会记住这些偶然模式。

     

    五. 机器学习的通用工作流程

    1.定义问题,收集数据集 --Defining the problem and assembling a dataset

    • 输入数据是什么?要预测什么?数据可用性通常是这一个阶段的限制因素。
    • 什么类型的问题?是二分类问题、多分类问题、标量回归问题、向量回归问题,还是多分类、多标签问题?或者是其他问题,比如聚类、生成或强化学习?确定问题,确定模型架构、Loss函数等。

    • 假设输出是可以根据输入进行预测的
    • 假设可用数据包含足够多的信息,足以学习输入和输出之间的关系

         收集的包含输入 X 和目标 Y 的很多样例,并不意味着 X 包含足够多的信息来预测 Y。例如,如果你想根据某支股票最近的历史价格来预测其股价走势,那你成功的可能性不大,因为历史价格 并没有包含很多可用于预测的信息。并非所有问题都可以解决:有一类无法解决的问题,那就是非平稳问题(nonstationary problem)

             机器学习只能用来记忆训练数据中存在的模式,只能识别出曾经见过的东西。 在过去的数据上训练机器学习来预测未来,这里存在一个假设,就是未来的规律与过去相同。 但事实往往并非如此。

    2.选择衡量成功的指标-- Choosing a measure of success

            成功的指标:精度? 准确率(precision)和召回率(recall)? 客户保留率?衡量成功的指标影响如何选择损失函数,即模型要优化什么。

             1. 平衡分类问题(balanced-classification problem)--->  精度和接收者操作特征曲线下面积(area under the receiver operating characteristic curveROC AUC)是常用的指标。

             2. 类别不平衡问题(class-imbalanced problems)---> 准确率和召回率

       3.排序问题或多标签分类---> 平均准确率均值(mean average precision)

     

    3.确定评估方法-- Deciding on an evaluation protocol

         总结一下前面介绍了三种常见的评估方法。如下:

    • 留出验证集。数据量很大时可以采用这种方法。
    • K 折交叉验证。如果留出验证的样本量太少,无法保证可靠性,那么应该选择这种方法。
    • 重复的 K 折验证。如果可用的数据很少,同时模型评估又需要非常准确,那么应该使用这种方法。

     

    4.准备数据-- Preparing your data

    • 应该将数据格式化为张量。
    • 这些张量的取值通常应该缩放为较小的值,比如在 [0, 1] 区间。
    • 如果不同特征具有不同的取值范围(异质数据),应该做数据标准化。
    • 可能需要做特征工程,尤其是对于小数据问题。

     

    5.开发模型--Developing a model that does better than a baseline

            

             统计功效(statistical power),即开发一个小型模型,它能够打败纯 随机的基准(dumb baseline),不一定总是能获得统计功效。如果尝试了多种合理架构之后仍然无法打败随机基准, 那么原因可能是问题的答案并不在输入数据中----体现元认知能力。

    • 假设输出是可以根据输入进行预测的。
    • 假设可用数据包含足够多的信息足以学习输入和输出之间的关系

    需要选择以下三个关键参数来构建第一个工作模型 :

    • 最后一层的激活: 对网络输出进行有效的限制。
    • 损失函数:它应该匹配你要解决的问题的类型。损失函数需要在只有小批量数据时即可计算(理想情况下,只有一个数据点时,损失函数应该也是可计算的),而且还必须是可微的(否则无法用反向传播来训练网络)。
    • 优化配置:要使用哪种优化器?学习率是多少?大多数情况下,使用 RMSprop 及其默认的学习率是稳妥的。

     

    6.扩大模型规模:开发过拟合的模型--Scaling up: developing a model that overfits

             机器学习中到处都是优化和泛化的对立,理想的模型是刚好在欠拟合和过拟合的界线上,在容量不足和容量过大的界线上。要搞清楚需要多大的模型,就必须开发一个过拟合的模型,如下操作即可:

             (1) 添加更多的层。

             (2) 让每一层变得更大。

             (3) 训练更多的轮次。

            要始终监控训练损失和验证损失,以及所关心的指标的训练值和验证值。如果发现模型在验证数据上的性能开始下降,那么就出现了过拟合。

     

    7. 模型正则化与调节超参数--Regularizing your model and tuning your hyperparameters

             这一步是最费时间的: 将不断地调节模型、训练、在验证数据上评估(而不是测试数据)、 再次调节模型,然后重复这一过程,直到模型达到最佳性能。主要调节如下几项:

    • 添加 dropout。
    • 尝试不同的架构: 增加或减少层数。
    • 添加 L1 和 / 或 L2 正则化。
    • 尝试不同的超参数(比如每层的单元个数或优化器的学习率),以找到最佳配置。
    • (可选)反复做特征工程: 添加新特征或删除没有信息量的特征。

          【请注意】每次使用验证过程的反馈来调节模型,都会将有关验证过程的信息泄露到模型中。如果只重复几次,那么无关紧要; 但如果系统性地迭代许多次,最终会导致模型对验证过程过拟合(即使模型并没有直接在验证数据上训练),这会降低验证过程的可靠性。

             一旦开发出令人满意的模型配置,就可以在所有可用数据(训练数据 + 验证数据)上训练最终的生产模型,然后在测试集上最后评估一次。如果测试集上的性能比验证集上差很多, 那么这可能意味着验证流程不可靠,或者在调节模型参数时在验证数据上出现了过拟合。 在这种情况下,可能需要换用更加可靠的评估方法,比如重复的 K 折验证。

     

     

     

    微信公众号:

    展开全文
  • 在前面的博文中,我们分享了《基于scikit-learn机器学习库的分类预测》,本文将分享Keras机器学习库的分类预测。 一旦你在Keras中选择好机器学习模型,就可以用它来预测新的数据实例。初学者经常会有这样的疑问: ...
  • python机器学习算法(Keras

    千次阅读 2017-09-05 08:35:07
    python机器学习算法
  • 现如今,人工智能已经应用到了各行各业,...今天介绍的就是如何使用机器学习中的Keras和tfjs来帮助医生建立AI医疗中的血细胞分类模型, 这里贴出一篇专业的文章:机器学习项目:使用Keras和tfjs构建血细胞分类模型...
  • 注意事项前言此文为 windows下学习环境搭建过程。Ubuntu 下 Tensorflow + Keras 生产环境搭建 后面会单独列出。下载安装程序包 下载安装 Anaconda Ptython 2.7 版本 下载安装 VS2013 打开工具 Anaconda Prompt, 并...
  • 说到机器学习,就不得不提深度学习,深度学习是机器学习中的一个组成分支,深度学习是机器学习研究中的一个新的领域,其动机在于建立、模拟人脑进行分析学习的神经网络,它模仿人脑的机制来解释数据,例如图像,...
  • Ubuntu14.04+GPU+keras机器学习环境配置

    千次阅读 2017-11-30 14:29:18
    1.首先安装Ubuntu14.04,这是Ubuntu系列最稳定的版本。 安装驱动,有条件使用GPU的,采用GPU加速。 2.安装GPU驱动过程: ...sudo stop lightdm sudo su sudo apt-get --purge remove nvidia-* ./NVIDIA(tab一下)........
  • 安装Anaconda3 下载地址: https://repo.continuum.io/archive/Anaconda3-5.1.0-Windows-x86_64.exe 使用Python3的64位版本 安装C++环境 下载地址: ... 安装CUDA 下...
  •  Auto-Keras是一个离线使用的开源库,用于构建神经网络结构和搜索超参数,支持RNN,CNN神经网络,它使用了高效神经网络搜索ENAS,利用迁移学习的原理将在前面任务中学到的权值应用于后期的模型中,...
  • Keras 2.1.4 TensorFlow 1.5.0 Anconda3 4.2.0 pycharm 2017.2.4 Keras环境搭建的时候,跟Anaconda、TensorFlow版本都有关系。测试了好几个,最终确定了上面的配置。 keras环境搭建 安装Anaconda3-4.2.0-...
  • macOS+Keras:安装与mnist_cnn实例测试
  • 配置学习过程:选择损失函数,优化器和需要监控的指标 调用模型的fit方法在训练数据上迭代 定义模型的方法 有两种方法: 使用Sequential类,仅仅用于层的线性堆叠,目前最常用 函数式API,可以构建任意形式的架构 ...
  • 我们都知道:Scikit-Learn,Keras,Tensorflow是机器学习工具链的重要组成部分。本书的作者,根据上述三个机器学习工具箱,融汇贯通成一个个机器学习实例,让即使对人工智...
  • 最新在学习Scikit-Learn 、机器学习Keras、卷积神经网络 相关技术,网上关于Scikit-Learn 、机器学习Keras的教程不多,特别是国内的,本着互联网是开放及分享的思想,我特地花些时间整理了相关视频教程,一个...
  • 深度学习是机器学习的一个子领域,想了解深度学习,首先要对机器学习的概念、方法有一定的理解。 机器学习的概念,百度百科中这样写道:机器学习是一门多领域交叉学科,涉及概率论、统计学、逼近论、凸分析、算法...
  • 安装Anaconda 参考我的另一篇博客 ...Cuda 版本之说,网上众说纷纭。具体讲一下我的配置,和我的个人看法。 配置如下: Gtx 1080 ti + Cuda9.0 + cudnn7.3 其实主要是Cuda版本,cudnn会有对应的版本提示。...
  • 使用keras深度学习实现回归问题示例

    万次阅读 2016-10-31 16:21:49
    通常情况下,我们都是用深度学习做分类,但有时候也会用来做回归。...1. 这里作者使用Keras 和python的scikit-learn机器学习库来实现了对房价的回归预测。关于scikit-learn与Keras联合可参考 Scikit-Learn接口包装
1 2 3 4 5 ... 20
收藏数 19,802
精华内容 7,920
关键字:

keras 机器学习