精华内容
下载资源
问答
  • 卷积神经网络python实现。 卷积神经网络(Convolutional Neural Networks, CNN)是一类包含卷积或相关计算且具有深度结构的前馈神经网络(Feedforward Neural Networks),是深度学习(deep learning)的代表算法之...
  • python 卷积神经网络

    2021-01-12 09:14:22
    实验二:卷积神经网络 手写体识别 数据准备 使用MNIST数字图像训练卷积神经网络 数据重塑和标签向量化 建立基础卷积模型 卷积模型是Conv2D层和MaxPooling2D层的堆叠,本例中卷积神经网络处理大小为(28,28,...

    实验二:卷积神经网络

    • 手写体识别
    • 数据准备

    使用MNIST数字图像训练卷积神经网络

    数据重塑和标签向量化

    • 建立基础卷积模型

    卷积模型是Conv2D层和MaxPooling2D层的堆叠,本例中卷积神经网络处理大小为(28,28,1)的输入张量,这正是MNIST图像的格式

    • 建立分类卷积模型

    • 模型建立与训练

    设置训练容器

    优化算法、损失函数、监督矩阵

    训练模型

    指定输入、输出,指定迭代次数,指定数据块大小

    • 结果测试

    • 自主练习
    1. 改变网络的深度和宽度

     

    深度

    宽度

    训练集精度

    测试集精度

    基准

    3

    64

    0.9938

     

    0.9919000267982483

     

    深度不变,减小宽度

    3

    32

    0.9920

     

    0.9886000156402588

     

    深度不变,增大宽度

    3

    128

    0.9950

     

    0.9922999739646912

     

    宽度不变,减小深度

    2

    64

    0.9954

     

    0.9873999953269958

     

    宽度不变,增大深度

    4

    64

    0.9936

     

    0.9891999959945679

     

    由此可见,增大卷积神经网络的宽度,训练集和测试集上的精度都有所增加。改变深度会导致测试集上的精度均有所下降。

    1. 改变优化算法

    优化算法

    训练集精度

    测试集精度

    Sgd

    0.9986
    0.9933000206947327

    Adagrad

    0.9924
    0.9912999868392944

    Adadelta

    0.9944
    0.9927999973297119

    RMSprop

    0.9944
    0.9918000102043152

    Adam

    0.9934
    0.9897000193595886

    Adamax

    0.9922
    0.9911000132560731

    由此可见,sgd算法对于该问题最有效

    • 猫、狗的二分类问题
    • 数据准备

    从数据目录中选取猫、狗的1000张、500张、500张图片分别作为训练数据、验证数据、测试数据,并建立相关目录进行存放。

    • 数据预处理

    将JPEG文件解码为RGB像素网格

    将这些像素网格转换为浮点数向量

    将像素值(0-255)缩放到[0,1]区间

    • 模型建立

    建立卷积层和池化层进行模型训练

    使用分类层进行二分类猫狗图片

    • 模型训练

    使用批量生成器拟合模型

    • 数据增强

    数据增强是从现有的训练样本中生成更多的训练模型,其方法是利用多种能够生成可信图像的随机变换来增加样本。其目标是,模型在训练时不会两次查看完全相同的图像。这让模型能够观察到数据的更多内容,从而具有更好的泛化能力。

    通过变换、旋转、压缩等来产生新的数据

    • 随机丢弃

    在模型中添加一个Dropout层,添加在密集连接分类器前

    • 结果分析
    • 预训练下的猫狗分类(不使用数据增强)
    • 预训练模型

    使用VGG16卷积网络提取特征

    • 分类模型建立

    • 模型建立与训练

    设置训练容器

    训练模型

    • 结果展示

     


    pytho

    展开全文
  • 基于Python卷积神经网络的图像分类,很适合初学者的学习使用
  • 基于卷积神经网络的Keras音频分类
  • 对于卷积神经网络(CNN)而言,相信很多读者并不陌生,该网络近年来在大多数领域都表现优异,尤其是在计算机视觉领域中。但是很多工作人员可能直接调用相关的深度学习工具箱搭建卷积神经网络模型,并不清楚其中具体...

    摘要: 本文概括地介绍CNN的基本原理 ,并通过阿拉伯字母分类例子具体介绍其实现过程,理论与实践的结合体。

    对于卷积神经网络(CNN)而言,相信很多读者并不陌生,该网络近年来在大多数领域都表现优异,尤其是在计算机视觉领域中。但是很多工作人员可能直接调用相关的深度学习工具箱搭建卷积神经网络模型,并不清楚其中具体的原理。本文将简单介绍卷积神经网络(CNN),方便读者大体上了解其基本原理及实现过程,便于后续工作中的实际应用。本文将按以下顺序展开:

    • 了解卷积操作
    • 了解神经网络
    • 数据预处理
    • 了解CNN
    • 了解优化器
    • 理解 ImageDataGenerator
    • 进行预测并计算准确性
    • demo

    什么是卷积?

    在数学(尤其是函数分析)中,卷积是对两个函数(f和g)的数学运算,以产生第三个函数,该函数表示一个函数的形状如何被另一个修改。

    此操作在多个领域都有应用,如概率、统计、计算机视觉、自然语言处理、图像和信号处理、工程和微分方程。
    该操作在数学上表示为:

    0
    卷积操作

    什么是人工神经网络?

    人工神经网络(ANN)或连接系统是由构成动物大脑的生物神经网络模糊地启发的计算系统。这些系统通过从示例中“学习”以执行任务,通常不需要使用用任何特定规则来编程。(来源:维基百科)

    人工神经网络是一个较小的处理单元集合,称为人工神经元,它们与生物神经元相似。

    生物神经回路

     

    1


    神经元之间的互联构成了一个网络模型

    人工神经网络

     

    2

    现在,我们开始具体实现。

    导入必要的数据包

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    import seaborn as sns
    
    import tflearn.data_utils as du
    from keras.models import Sequential
    from keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPool2D
    from keras.optimizers import RMSprop
    from keras.preprocessing.image import ImageDataGenerator
    from sklearn.metrics import confusion_matrix

    加载数据集

    train_data = pd.read_csv('../input/csvTrainImages 13440x1024.csv', header = None)
    train_label = pd.read_csv('../input/csvTrainLabel 13440x1.csv', header = None)
    test_data = pd.read_csv('../input/csvTestImages 3360x1024.csv', header = None)
    test_label = pd.read_csv('../input/csvTestLabel 3360x1.csv', header = None)

    数据集

    此处使用的数据集是手写数据集。
    trainIamges.csv有1024列和13440行。每列表示图像中的像素,每行表示一张单独的灰度图像。每个像素的取值范围是0到255之间的值。

    train_data = train_data.iloc[:,:].values.astype('float32')
    train_label = train_label.iloc[:,:].values.astype('int32')-1
    test_data = test_data.iloc[:,:].values.astype('float32')
    test_label = test_label.iloc[:,:].values.astype('int32')-1

    可视化数据集

    def row_calculator(number_of_images, number_of_columns):
        if number_of_images % number_of_columns != 0:
            return (number_of_images / number_of_columns)+1
        else:
            return (number_of_images / number_of_columns)
    
    def display_image(x, img_size, number_of_images):
        plt.figure(figsize = (8, 7))
        if x.shape[0] > 0:
            n_samples = x.shape[0]
            x = x.reshape(n_samples, img_size, img_size)
            number_of_rows = row_calculator(number_of_images, 4)
            for i in range(number_of_images):
                plt.subplot(number_of_rows, 4, i+1)
                plt.imshow(x[i])

    训练数据集

    display_image(train_data, 32, 16)

     

    3
    训练数据集

    测试数据集

    display_image(test_data, 32, 16)

     

    4
    测试数据集

    数据预处理

    编码分类变量

    什么是分类变量?

    在统计学中,分类变量是一个可以承担限制变量之一的变量,基于某些定性属性将每个个体或其他观察单元分配给特定组或名义类别。

    简单来说,分类变量的值表示类别或类。

    为什么需要编码分类变量?

    直接对表示类别的数字执行操作没有意义。因此,需要对其进行分类编码。

    阿拉伯字母表中有28个字母。因此,数据集有28个类别。

    train_label = du.to_categorical(train_label,28)

    标准化

    什么是标准化?

    进行归一化以使整个数据进入明确定义的范围,一般选择归一化到0到1之间

    在神经网络中,不仅要对数据进行标准化,还要对其进行标量化,这样处理的目的是能够更快地接近错误表面的全局最小值。

    train_data = train_data/255
    test_data = test_data/255
    
    train_data = train_data.reshape([-1, 32, 32, 1])
    test_data = test_data.reshape([-1, 32, 32, 1])
    

    对其进行变形操作使得每条数据表示一个平面图像

    train_data, mean1 = du.featurewise_zero_center(train_data)
    test_data, mean2 = du.featurewise_zero_center(test_data)

    按功能划分的零中心将每个样本的中心置零,并指定平均值。如果未指定,则对所有样品评估平均值。

    建立CNN

    recognizer = Sequential()
    
    recognizer.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'Same', activation ='relu', input_shape = (32,32,1)))
    recognizer.add(Conv2D(filters = 32, kernel_size = (5,5),padding = 'Same', activation ='relu'))
    recognizer.add(MaxPool2D(pool_size=(2,2)))
    recognizer.add(Dropout(0.25))
    
    recognizer.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same', activation ='relu'))
    recognizer.add(Conv2D(filters = 64, kernel_size = (3,3),padding = 'Same', activation ='relu'))
    recognizer.add(MaxPool2D(pool_size=(2,2), strides=(2,2)))
    recognizer.add(Dropout(0.25))
    
    recognizer.add(Flatten())
    recognizer.add(Dense(units = 256, input_dim = 1024, activation = 'relu'))
    recognizer.add(Dense(units = 256, activation = "relu"))
    recognizer.add(Dropout(0.5))
    recognizer.add(Dense(28, activation = "softmax"))

    最大池化(Max Pooling)是什么?

    池化意味着组合一组数据,组合数据的过程中应该遵循一些规则。

    根据定义,最大池化选取一组数据中的最大值作为其输出值。

    最大池还可以用于减小特征维度,它还可以避免过拟合的发生。加入QQ群519970686,以便更好地了解Python与人工智能

    什么是Dropout?

    Dropout是一种正则化技术,通过防止对训练数据进行复杂的协同适应来减少神经网络中的过拟合,这是神经网络模型中十分有效的方法之一。“ 丢失”指的是在神经网络中以某一个概率随机地丢弃部分神经单元。

    什么是Flatten?

    对特征图进行展平,以将多维数据转换为一维特征向量,以供下一层(密集层)使用

    什么是密集层?

    密集层只是一层人工神经网络,也被称作全连接层。

    CNN的优化方法

    什么是优化?

    优化算法帮助我们最小化(或最大化)目标函数,目标函数只是一个数学函数,取决于模型内部可学习的参数。模型中使用预测变量集(X)计算目标值(Y)。例如,我们将神经网络的权重(W)和偏差(b)值称为其内部可学习参数,用于计算输出值,并在最优解的方向上学习和更新这些参数,即最小化损失网络。这就是神经网络的训练过程。

    optimizer = RMSprop(lr=0.001, rho=0.9, epsilon=1e-08, decay=0.0)
    

    本文在这里使用的优化器是RMSprop,点击此处以了解有关RMSprop的更多信息。

    recognizer.compile(optimizer = optimizer , loss = "categorical_crossentropy", metrics=["accuracy"])
    

    什么是ImageDataGenerator?

    当你的数据集规模比较小时,你可能会应用到图像数据生成器,它用于生成具有实时增强的批量张量图像数据,扩大数据集规模。一般而言,当数据量增多时,模型性能会得更好。
    以下代码用于批量加载图像:

    datagen = ImageDataGenerator(
            featurewise_center=False, 
            samplewise_center=False,  
            featurewise_std_normalization=False,
            samplewise_std_normalization=False,
            zca_whitening=False,
            rotation_range=10,
            zoom_range = 0.1,  
            width_shift_range=0.1, 
            height_shift_range=0.1,
            horizontal_flip=False,
            vertical_flip=False)
    
    datagen.fit(train_data)

    CNN拟合训练数据

    recognizer.fit_generator(datagen.flow(train_data,train_label, batch_size=100), epochs = 30, verbose = 2, steps_per_epoch=train_data.shape[0] // 100)

    做出预测

    predictions = recognizer.predict(test_data)
    predictions = np.argmax(predictions,axis = 1)

    生成混淆矩阵

    什么是混淆矩阵?

    混淆矩阵是用于总结分类算法性能的一种技术。如果每个类别中的观察数量不等,或者数据集中有两个以上的类,单独的分类准确性可能会产生误导。计算混淆矩阵可以让我们更好地了解分类模型的正确性以及它所犯的错误类型。

    cm = confusion_matrix(test_label, predictions)
    

    计算准确性

    accuracy = sum(cm[i][i] for i in range(28)) / test_label.shape[0]
    print("accuracy = " + str(accuracy))

    本文获得了97%的准确度,感兴趣的读者可以自己尝试下。

    展开全文
  • python写的卷积神经网络进行图片分类,spyder中运行有效,代码中有详细的注释,希望对下载的朋友有用。
  • 1、大型卷积神经网络 import numpy as np from keras.datasets import cifar10 from keras.models import Sequential from keras.layers import Dense from keras.layers import Dropout from keras.layers import...

    1、大型卷积神经网络

    import numpy as np
    from keras.datasets import cifar10
    from keras.models import Sequential
    from keras.layers import Dense
    from keras.layers import Dropout
    from keras.layers import Flatten
    from keras.layers.convolutional import Conv2D
    from keras.layers.convolutional import MaxPooling2D
    from keras.optimizers import SGD
    from keras.constraints import maxnorm
    from keras.utils import np_utils
    from keras import backend
    backend.set_image_data_format('channels_first')
    
    # 设定随机种子
    seed = 7
    np.random.seed(seed=seed)
    
    # 导入数据
    (X_train, y_train), (X_validation, y_validation) = cifar10.load_data()
    
    # 格式化数据到0-1之前
    X_train = X_train.astype('float32')
    X_validation = X_validation.astype('float32')
    X_train = X_train / 255.0
    X_validation = X_validation / 255.0
    
    # one-hot编码
    y_train = np_utils.to_categorical(y_train)
    y_validation = np_utils.to_categorical(y_validation)
    num_classes = y_train.shape[1]
    
    def create_model(epochs=25):
        model = Sequential()
        model.add(Conv2D(32, (3, 3), input_shape=(3, 32, 32), padding='same', activation='relu', kernel_constraint=maxnorm(3)))
        model.add(Dropout(0.2))
        model.add(Conv2D(32, (3, 3), activation='relu', padding='same', kernel_constraint=maxnorm(3)))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Conv2D(64, (3, 3), activation='relu', padding='same', kernel_constraint=maxnorm(3)))
        model.add(Dropout(0.2))
        model.add(Conv2D(64, (3, 3), activation='relu', padding='same', kernel_constraint=maxnorm(3)))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Conv2D(128, (3, 3), activation='relu', padding='same', kernel_constraint=maxnorm(3)))
        model.add(Dropout(0.2))
        model.add(Conv2D(128, (3, 3), activation='relu', padding='same', kernel_constraint=maxnorm(3)))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Flatten())
        model.add(Dropout(0.2))
        model.add(Dense(1024, activation='relu', kernel_constraint=maxnorm(3)))
        model.add(Dropout(0.2))
        model.add(Dense(512, activation='relu', kernel_constraint=maxnorm(3)))
        model.add(Dropout(0.2))
        model.add(Dense(10, activation='softmax'))
        # 默认情况下,这里的学习率是线性衰减的
        # learningRate =  learningRate * 1/(1 + decay*epoch)
        # 当decay衰减为0时(默认值),对学习率没有影响;当使用非0学习率衰减时,学习率呈线性衰减
        # decay不为0的情况下,学习率随着epochs的增大而减少
        lrate = 0.01
        decay = lrate / epochs
        sgd = SGD(lr=lrate, momentum=0.9, decay=decay, nesterov=False)
        model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
        return model
    
    epochs = 25
    model = create_model(epochs)
    model.fit(x=X_train, y=y_train, epochs=epochs, batch_size=32, verbose=2)
    scores = model.evaluate(x=X_validation, y=y_validation, verbose=0)
    print('Accuracy: %.2f%%' % (scores[1] * 100))
    

    改进型模型

    import keras
    import numpy as np
    from keras.datasets import cifar10
    from keras.models import Sequential
    from keras.layers import Dropout, Activation
    from keras.layers import Conv2D, MaxPooling2D, GlobalAveragePooling2D
    from keras.initializers import RandomNormal
    from keras import optimizers
    from keras.callbacks import LearningRateScheduler, TensorBoard
    
    batch_size = 128
    epochs = 200
    iterations = 391
    num_classes = 10
    dropout = 0.5
    log_filepath = './nin'
    
    
    def normalize_preprocessing(x_train, x_validation):
    
        #首先把x_train和x_validation设置数据类型为float32
        x_train = x_train.astype('float32')
        x_validation = x_validation.astype('float32')
        mean = [125.307, 122.95, 113.865]
        std = [62.9932, 62.0887, 66.7048]
        #然后分别对每一个图像数据的每一个通道进行归一化操作
        for i in range(3):
            x_train[:, :, :, i] = (x_train[:, :, :, i] - mean[i]) / std[i]
            x_validation[:, :, :, i] = (x_validation[:, :, :, i] - mean[i]) / std[i]
    
        return x_train, x_validation
    
    
    def scheduler(epoch):
        if epoch <= 60:
            return 0.05
        if epoch <= 120:
            return 0.01
        if epoch <= 160:
            return 0.002
        return 0.0004
    
    
    def build_model():
        model = Sequential()
    
        model.add(Conv2D(192, (5, 5), padding='same', kernel_regularizer=keras.regularizers.l2(0.0001),
                         kernel_initializer=RandomNormal(stddev=0.01), input_shape=x_train.shape[1:],
                         activation='relu'))
        model.add(Conv2D(160, (1, 1), padding='same', kernel_regularizer=keras.regularizers.l2(0.0001),
                         kernel_initializer=RandomNormal(stddev=0.05), activation='relu'))
        model.add(Conv2D(96, (1, 1), padding='same', kernel_regularizer=keras.regularizers.l2(0.0001),
                         kernel_initializer=RandomNormal(stddev=0.05), activation='relu'))
        model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same'))
    
        model.add(Dropout(dropout))
    
        model.add(Conv2D(192, (5, 5), padding='same', kernel_regularizer=keras.regularizers.l2(0.0001),
                         kernel_initializer=RandomNormal(stddev=0.05), activation='relu'))
        model.add(Conv2D(192, (1, 1), padding='same', kernel_regularizer=keras.regularizers.l2(0.0001),
                         kernel_initializer=RandomNormal(stddev=0.05), activation='relu'))
        model.add(Conv2D(192, (1, 1), padding='same', kernel_regularizer=keras.regularizers.l2(0.0001),
                         kernel_initializer=RandomNormal(stddev=0.05), activation='relu'))
        model.add(MaxPooling2D(pool_size=(3, 3), strides=(2, 2), padding='same'))
    
        model.add(Dropout(dropout))
    
        model.add(Conv2D(192, (3, 3), padding='same', kernel_regularizer=keras.regularizers.l2(0.0001),
                         kernel_initializer=RandomNormal(stddev=0.05), activation='relu'))
        model.add(Conv2D(192, (1, 1), padding='same', kernel_regularizer=keras.regularizers.l2(0.0001),
                         kernel_initializer=RandomNormal(stddev=0.05), activation='relu'))
        #在这里并没有像传统一样把activation设置为softmax
        model.add(Conv2D(10, (1, 1), padding='same', kernel_regularizer=keras.regularizers.l2(0.0001),
                         kernel_initializer=RandomNormal(stddev=0.05), activation='relu'))
    
        #
        model.add(GlobalAveragePooling2D())
        # 单独增加一个激活层
        model.add(Activation('softmax'))
    
        sgd = optimizers.SGD(lr=0.1, momentum=0.9, nesterov=True)
        model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
        return model
    
    
    if __name__ == '__main__':
        np.random.seed(seed=7)
        # load data
        (x_train, y_train), (x_validation, y_validation) = cifar10.load_data()
        y_train = keras.utils.to_categorical(y_train, num_classes)
        y_validation = keras.utils.to_categorical(y_validation, num_classes)
    
        x_train, x_validation = normalize_preprocessing(x_train, x_validation)
    
        # build network
        model = build_model()
        print(model.summary())
    
        # set callback
        # 使用了回调函数
        tb_cb = TensorBoard(log_dir=log_filepath, histogram_freq=0)
        change_lr = LearningRateScheduler(scheduler)
        cbks = [change_lr, tb_cb]
    
    
        # set data augmentation
        print('Using real-time data augmentation.')
        from keras.preprocessing.image import ImageDataGenerator
        datagen = ImageDataGenerator(horizontal_flip=True, width_shift_range=0.125, height_shift_range=0.125,
                                     fill_mode='constant', cval=0.)
        datagen.fit(x_train)
    
        # start training
        model.fit_generator(datagen.flow(x_train, y_train, batch_size=batch_size), steps_per_epoch=iterations,
                            epochs=epochs, callbacks=cbks, validation_data=(x_validation, y_validation), verbose=2)
    
        #model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, callbacks=cbks,
        #         validation_data=(x_validation, y_validation), verbose=2)
        #保存模型
        model.save('nin.h5')

     

    展开全文
  • TensorFlow 实现卷积神经网络对句子分类的任务
  • 卷积神经网络基于 Tensorflow 实现的中文文本分类
  • 机器学习第三次小作业,要求实现全连接神经网络,RBF神经网络和CNN分类器,做了三天,终于把这些都弄得差不多明白了,利用Python和TensorFlow把这些实现一下,代码放这里做个记录(怕以后丢了忘了)。在这个过程中...

    一、概述

    机器学习第三次小作业,要求实现全连接神经网络,RBF神经网络和CNN分类器,做了三天,终于把这些都弄得差不多明白了,利用Python和TensorFlow把这些实现一下,代码放这里做个记录(怕以后丢了忘了)。在这个过程中遇到很多问题,从神经网络的前向传播到反向传播,从网络结构设计到参数调整,里面需要学习的地方太多了,不同的网络具有不同的特征,但是时间有限,这里先记录个问题大纲,等寒假回家看看能不能把这个再详细补充一下。

    二、问题大纲

    1. 全连接神经网络

    (1)前向传播:样本输入先乘个权重矩阵,通过隐含层神经元处理一下,隐含层输出再与下一个矩阵权重相乘,然后再经过神经元处理,具体需要多少隐含层视情况而定;
    (2)反向传播:反向传播这个过程就可以直接利用TensorFlow中的优化方法就行,设置好学习率和定义好损失函数即可;
    (3)损失函数:一般分类问题,我个人觉得把标签转化成onehot表示比较好,例如一共有5种标签,那么标签为3转化成的onehot形式就是[0,0,1,0,0][0,0,1,0,0],如果使用这种形式的标签,那么最后输出的维度肯定是与标签类别数一致,损失函数也应该使用交叉熵来定义。当然可以使用原始的标签,那么最后输出就是一个值,如果利用batch样本的话,可以使用均方差来定义损失函数;

    2. RBF神经网络

    (1)前向传播:与全连接神经网络不同的是,RBF前向传播不需要通过权重矩阵来连接输入层与隐含层,将数据直接放到隐含层进行径向基函数的映射,不过隐含层到输出层是通过权重矩阵连接的,这两层与全连接神经网络的处理过程相同;
    (2)训练参数:RBF实际上在神经网络的训练过程中需要训练的参数只有隐含层到输出层之间的权重矩阵,另外还有两个参数是隐含层的中心点cc和方差σ\sigma(其实我觉得也可以把隐含层的中心点与方差都放入网络中一起训练)。对于分类问题,如果数据有多少类,那么隐含层就有多少个节点,也就是cc有多少个。计算中心点的方法大概有三种,我个人觉得使用KMeans聚类得到中心点方法比较好。对于σ\sigma的计算,我看了一些资料,说法不一。对于σi\sigma_i,有人说是计算当前隐含层节点i的中心点cic_i与其他所有节点的中心点的最大距离,也有人说是最小距离乘上一个系数λ\lambda,我觉得差别不大。对于高斯径向基exci2σ2e^{-\frac{\|x-c_i\|^2}{\sigma^2}},(个人猜测)其实本质上的一个原因就是给数据做一个标准化,否则可能造成计算出的距离d=xci2d=\|x-c_i\|^2过大(其实也没有很大,但是ede^{-d}就会基本为0)。总结一下,cc是一个数据类别数N*样本维度M的矩阵,σ\sigma是一个N维的向量。
    (3)准确率:目前还不知道为什么,使用RBF神经网络对MNIST、Yale、lung以及gisette、COIL20等等的数据集训练的准确率很低,20%不到,试过了很多种方法,依然没能有效的解决这个问题,但是不知道为什么,我自己随机生成了一组数据,训练的准确率能到70%,具体原因还得继续深挖。

    3. 卷积神经网络

    (1)卷积层:对于本次实验来说,在卷积层所做的操作都是先把输入的一个样本reshape成一个二维矩阵,然后定义卷积核(卷积核的数量和大小自己定合适即可,而卷积核的维度也就是所说的通道数根据数据决定,如果数据只是一个灰度图,那么维度为1,如果为RGB三通道,那么维度为3)。这里需要注意一点的是,如果定义了两层卷积层,那么第二层的卷积核通道数就是第一层卷积核的数量(可以自行推演一遍,很容易理解),在本次作业中,我定义了两层卷积层;
    (2)池化层:在卷积层之后起到对数据收缩的作用,很大程度降低参数规模,同时能够较好保持数据特征,比如某个卷积核卷积后得到一个32×3232\times32的数据,利用2×22\times2的池化层池化后就会得到一个16×1616\times16的数据。
    (3)全连接层:全连接层就是连接最后一个池化层/卷积层到输出层的权重矩阵,和上述全连接神经网络与RBF神经网络的最后一个权重矩阵作用相同。CNN的训练需要较大数量的数据,才能保证较高的准确率。

    三、代码

    datadvi.py

    from scipy.io import loadmat
    import numpy as np
    
    def divdata():
        filename = 'C:/Users/ALIENWARE/Documents/作业/机器学习/datasets/' + input("input name of data file: ")
        data = loadmat(filename)
    
    
        if filename == 'C:/Users/ALIENWARE/Documents/作业/机器学习/datasets/COIL20.mat':
            dataX = data['fea']
            dataY = data['gnd'][0]
            print(len(dataX[0]))
        else:
            dataX = data['X']
            dataY = data['Y'].T[0]
    
        divideornot = input("divide data or not?(Yes/No): ")
        if divideornot == 'Yes':
            dataX_train = []
            dataX_predict = []
            dataY_train = []
            dataY_predict = []
            num_Y = np.unique(dataY).astype(int)
            for i in range(len(num_Y)):
                temp = dataY == num_Y[i]
                temp.astype(float)
                num_Y[i] = np.sum(temp)
                flag = 0
                for j in range(len(dataY)):
                    if temp[j] == 1:
                        if flag < int(round(0.9 * num_Y[i])):
                            dataX_train.append(dataX[j])
                            dataY_train.append(dataY[j])
                            flag += 1
                        else:
                            dataX_predict.append(dataX[j])
                            dataY_predict.append(dataY[j])
    
            dataX_train = np.array(dataX_train)
            dataX_predict = np.array(dataX_predict)
            dataY_train = np.array(dataY_train)
            dataY_predict = np.array(dataY_predict)
            return dataX_train,dataX_predict,dataY_train,dataY_predict
        else:
            return dataX,dataX,dataY,dataY
    

    FullyConnectedNN.py

    import tensorflow as tf
    import datadvi
    import numpy as np
    
    def FCNN(batch_size=50,learning_rate=0.0001,iteration_times=5000):
        dataX_train,dataX_predict,dataY_train,dataY_predict = datadvi.divdata()
        X = dataX_train
        Y1 = dataY_train
        print(Y1)
        num_label = len(np.unique(Y1))
        Y = (np.arange(num_label)+1 == Y1[:, None]).astype(np.float32)
        dataY_predict1 = (np.arange(num_label)+1 == dataY_predict[:, None]).astype(np.float32)
        x = tf.placeholder(tf.float32, shape=[None, len(X[0])])
        y = tf.placeholder(tf.float32, shape=[None, num_label])
    
        w1 = tf.Variable(tf.random_normal([len(X[0]), 256], stddev=1, seed=1))
        w2 = tf.Variable(tf.random_normal([256, 256], stddev=1, seed=1))
        w_out = tf.Variable(tf.random_normal([256, num_label], stddev=1, seed=1))
    
        b1 = tf.Variable(tf.random_normal([256]))
        b2 = tf.Variable(tf.random_normal([256]))
        b_out = tf.Variable(tf.random_normal([num_label]))
    
        def Fully_neural_network(X):
            layer_1 = tf.nn.relu(tf.add(tf.matmul(X, w1), b1))
            layer_2 = tf.nn.relu(tf.add(tf.matmul(layer_1, w2), b2))
            layer_out = tf.matmul(layer_2, w_out) + b_out
    
            return layer_out
    
        net_out = Fully_neural_network(x)
    
        pre = tf.nn.softmax(net_out)
        pre1 = tf.argmax(pre, 1)
    
        loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=net_out, labels=y))
        # loss = tf.reduce_mean(tf.abs(net_out-y))
    
        optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
        train_op = optimizer.minimize(loss)
    
        correct_pre = tf.equal(tf.argmax(pre, 1), tf.argmax(y, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_pre, tf.float32))
    
        init = tf.global_variables_initializer()
    
        with tf.Session() as sess:
            sess.run(init)
    
            for i in range(1, iteration_times + 1):
                start = (i * batch_size) % len(X)
                end = min(start + batch_size, len(X))
                batch_x = X[start:end]
                batch_y = Y[start:end]
                sess.run(train_op, feed_dict={x: batch_x, y: batch_y})
                if i % 100 == 0 or i == 1:
                    l, acc = sess.run([loss, accuracy], feed_dict={x: dataX_predict, y: dataY_predict1})
                    print("Step " + str(i) + ", Minibatch Loss= " + "{:.4f}".format(
                        l) + ", Training Accuracy= " + "{:.3f}".format(acc))
    
                    print(pre1.eval(feed_dict={x: batch_x}))
    

    RBFNN.py

    import tensorflow as tf
    import datadvi
    import Acc
    import numpy as np
    import random
    from sklearn.cluster import KMeans
    from numpy.random import RandomState
    
    from sklearn.preprocessing import StandardScaler
    from sklearn.preprocessing import MinMaxScaler
    
    def compute_sigma(c):
        sigma = np.zeros([len(c)])
        for i in range(len(c)):
            for j in range(len(c)):
                temp_dist = np.sum(np.square(c[i]-c[j]))
                if sigma[i] < temp_dist:
                    sigma[i] = temp_dist
        print(sigma)
        return sigma
    
    def init_C(dataX,num_label,label):
        c=np.empty(shape=(num_label,dataX.shape[-1]),dtype=np.float32)
        for i in range(num_label):
            c[i] = random.choice(dataX[label[:]==i+1])
        print(c)
        return c
    
    def cluster_center(dataX, num_label):
        KM = KMeans(n_clusters=num_label,random_state=0).fit(dataX)
        return KM.cluster_centers_
    
    def gen_data():
        rdm = RandomState(1)
        dataset_size = 1280
        X = rdm.rand(dataset_size, 2)
        Y1 = [[int(x1 + x2 < 1)] for (x1, x2) in X]
        Y = np.array(Y1).T[0]
    
        return X,X,Y,Y
    
    def RBFNN(batch_size=50,learning_rate=0.01,iteration_times=10000):
        dataX_train, dataX_predict, dataY_train, dataY_predict = datadvi.divdata() #划分训练集和测试集
        #dataX_train, dataX_predict, dataY_train, dataY_predict = gen_data()
    
        #数据标准化
        #dataX_train =  StandardScaler().fit_transform(dataX_train)
        #dataX_predict = StandardScaler().fit_transform(dataX_predict)
        #print(len(dataX_predict[0]))
        #dataX_train = (dataX_train-np.mean(dataX_train,axis=0))/np.std(dataX_train,axis=0)
        #dataX_predict = (dataX_predict - np.mean(dataX_predict, axis=0)) / np.std(dataX_predict, axis=0)
        #print(dataX_predict)
    
        num_label = len(np.unique(dataY_train)) #数据种类
        num_feature = len(dataX_train[0]) #数据维度
        print(num_label)
    
        # 将标签转换成onehot形式
        dataY_train_onehot = (np.arange(num_label) + 1 == dataY_train[:, None]).astype(np.float32)
        dataY_predict_onehot = (np.arange(num_label) + 1 == dataY_predict[:,None]).astype(np.float32)
    
        #使用原始标签数据
        dataY_train_origin = np.array([dataY_train]).T
        dataY_predict_origin = np.array([dataY_predict]).T
    
        #定义占位
        X = tf.placeholder(tf.float32,shape=[None,num_feature])
        #Y = tf.placeholder(tf.float32,shape=[None,num_label])
        Y = tf.placeholder(tf.float32,shape=[None,1])
    
        #初始化中心点c和sigma(隐藏节点数与数据种类相同)
        #c = tf.Variable(tf.random_normal([num_label,num_feature]))
        #c = tf.Variable(c1)
        c = cluster_center(dataX_train,num_label)
        #c = tf.Variable(tf.cast(c,tf.float32))
    
        #sigma = tf.Variable(tf.ones([num_label]))
        sigma1 = compute_sigma(c)
        sigma = tf.Variable(tf.cast(sigma1,tf.float32))
        #sigma = tf.Variable(tf.cast(c[:,0],tf.float32))
        #print(sigma)
    
        #初始化权重W(使用onehot表示则输出节点数与种类相同)
        #W = tf.Variable(tf.random_normal([num_label,num_label]))
    
        W = tf.Variable(tf.random_normal([num_label,1]))
    
        #计算隐藏节点输出K1
        #sigma2 = tf.square(sigma)
        K = []
        for i in range(num_label):
            K.append(tf.reduce_sum(tf.square((X - c[i])), 1)/sigma[i])
        K_tensor = tf.convert_to_tensor(K)
        K1 = tf.exp(-tf.transpose(K_tensor))
    
        #计算输出层output
        output = tf.matmul(K1,W)
    
        #四舍五入得到预测标签
        pred = tf.round(output)
        #pred = tf.argmax(output,1)
    
        #定义损失函数loss(使用softmax交叉熵方法)
        #loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=output, labels=Y))
        loss = tf.reduce_sum(tf.abs(tf.subtract(output,Y)))
    
        #选择优化方法
        #optimization = tf.train.AdamOptimizer(learning_rate).minimize(loss)
        optimization = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)
    
        with tf.Session() as sess:
            sess.run(tf.global_variables_initializer())
            for i in range(1,1+iteration_times):
                start = (i * batch_size) % dataX_train.shape[0]
                end = min(start + batch_size, dataX_train.shape[0])
                batch_x = dataX_train[start:end]
                batch_y = dataY_train_origin[start:end]
                #print(K1.eval(feed_dict={X:batch_x}))
                #print(b.eval())
                sess.run(optimization,feed_dict={X:batch_x,Y:batch_y})
                if i%10 == 0 or i==1:
                    print("loss of step {} is {}".format(i,loss.eval(feed_dict={X:dataX_train,Y:dataY_train_origin})))
                    print("ACC is: ",Acc.acc(np.array(pred.eval(feed_dict={X:dataX_train})).T[0],dataY_train))
    

    CNN.py

    import tensorflow as tf
    import datadvi
    import numpy as np
    import math
    
    sess = tf.InteractiveSession()
    
    
    def weight_variable(shape):
        initial = tf.truncated_normal(shape, stddev=0.1)  # 标准差为0.1的正态分布
        return tf.Variable(initial)
    
    
    def bias_variable(shape):
        initial = tf.constant(0.1, shape=shape)  # 偏差初始化为0.1
        return tf.Variable(initial)
    
    
    def conv2d(x, W):
        return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
    
    
    def max_pool_2x2(x):
        return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                              strides=[1, 2, 2, 1], padding='SAME')
    
    
    def cnn(batch_size=50,learning_rate=0.0001,iteration_times=5000):
        dataX_train, dataX_predict, dataY_train, dataY_predict = datadvi.divdata()
        num_label = len(np.unique(dataY_train))
    
        dataY_train_onehot = (np.arange(num_label) + 1 == dataY_train[:, None]).astype(np.float32)
        dataY_predict_onehot = (np.arange(num_label) + 1 == dataY_predict[:,None]).astype(np.float32)
    
        x = tf.placeholder(tf.float32, [None, len(dataX_train[0])])
        y_ = tf.placeholder(tf.float32, [None, num_label])
        # -1代表先不考虑输入的图片例子多少这个维度,1是channel的数量
        mat_XY = int(math.sqrt(len(dataX_train[0])))
    
        if mat_XY*mat_XY == len(dataX_train[0]):
            x_image = tf.reshape(x, [-1, mat_XY, mat_XY, 1]) #这适合数据维度能够开方得到整数的数据集, MNIST 和  COIL20等
        else:
            x_image = tf.reshape(x,[-1,50,100,1]) #这是gisette的数据参数大小设置
    
    
        keep_prob = tf.placeholder(tf.float32)
    
        # 构建卷积层1
        W_conv1 = weight_variable([5, 5, 1, 32])  # 卷积核5*5,1个channel,32个卷积核,形成32个featuremap
        b_conv1 = bias_variable([32])  # 32个featuremap的偏置
        h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)  # 用relu非线性处理
        h_pool1 = max_pool_2x2(h_conv1)  # pooling池化
    
    
        # 构建卷积层2
        W_conv2 = weight_variable([5, 5, 32, 64])  # 注意这里channel值是32
        b_conv2 = bias_variable([64])
        h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
        h_pool2 = max_pool_2x2(h_conv2)
    
    
        # 构建全连接层1
        W_fc1 = weight_variable([ int(mat_XY/4* mat_XY/4 * 64), 1024])
        #W_fc1 = weight_variable([int(50*100/4*64),1024]) #这是gisette的数据参数大小设置
        b_fc1 = bias_variable([1024])
        h_pool3 = tf.reshape(h_pool2, [-1, int(mat_XY/4* mat_XY/4 * 64)])
        #h_pool3 = tf.reshape(h_pool2,[-1,int(50*100/4*64)]) #这是gisette的数据参数大小设置
        h_fc1 = tf.nn.relu(tf.matmul(h_pool3, W_fc1) + b_fc1)
        h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
    
        # 构建全连接层2
        W_fc2 = weight_variable([1024, num_label])
        b_fc2 = bias_variable([num_label])
        y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
    
        cross_entropy = tf.reduce_mean(-tf.reduce_sum(y_ * tf.log(y_conv), reduction_indices=[1]))
        train_step = tf.train.AdamOptimizer(learning_rate).minimize(cross_entropy)
        correct_prediction = tf.equal(tf.arg_max(y_conv, 1), tf.arg_max(y_, 1))
        accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    
        tf.global_variables_initializer().run()
    
        for i in range(iteration_times):
            start = (i * batch_size) % dataX_train.shape[0]
            end = min(start + batch_size, dataX_train.shape[0])
            batch_x = dataX_train[start:end]
            batch_y = dataY_train_onehot[start:end]
            if i % 100 == 0:
                train_accuracy = accuracy.eval(feed_dict={x: batch_x, y_: batch_y, keep_prob: 1.0})
                print("step %d, training accuracy %g" % (i, train_accuracy))
                print("loss is: ", cross_entropy.eval(feed_dict={x:batch_x,y_:batch_y,keep_prob:1.0}))
            train_step.run(feed_dict={x: batch_x, y_: batch_y, keep_prob: 0.5})
        print("test accuracy %g" % accuracy.eval(feed_dict={x: dataX_predict,
                                                            y_: dataY_predict_onehot, keep_prob: 1.0}))
    

    network.py

    import FullyConnectedNN
    import RBFNN
    import CNN
    
    batch_size = int(input("input batch_size: "))
    learning_rate = float(input("input learning_rate: "))
    iteration_times = int(input("input iteration_times: "))
    
    method = int(input("choose a NN (1/FCNN  2/RBFNN 3/CNN): "))
    
    if method == 1:
        FullyConnectedNN.FCNN(batch_size,learning_rate,iteration_times)
    
    if method == 2:
        RBFNN.RBFNN(batch_size,learning_rate,iteration_times)
    
    if method == 3:
        CNN.cnn(batch_size,learning_rate,iteration_times)
    

    运行network.py即可。哎呦,终于把这个实习做完了,天天睡觉脑子里就是矩阵。

    展开全文
  • 这是用于乳房密度分类的模型的实现,如我们的论文“使用深度卷积神经网络的乳房密度分类”所述。 该实现允许用户通过应用我们的预训练模型之一来获得乳房密度预测:基于直方图的模型或多视图CNN。 这两种模式都采用...
  • 基于Python的LeNet-5卷积神经网络的实现(分类
  • 使用卷积神经网络完成 MNIST 分类; 实现了诸如数据增加,丢弃,批量规范化等
  • 本项目的所有代码均已在Python3.6及Pycharm平台调试通过,除了代码外,还提供《卷积神经网络(CNN)详解与代码实现》文档和《Notes on Convolutional Neural Networks》文档,其中:《卷积神经网络(CNN)详解与代码实现...
  • 卷积神经网络 当你听到说深度学习打破了某项新技术障碍,那么十有八九就会涉及到卷积神经网络。它们也被称作CNNs或着ConvNets,是深层神经网络领域的主力。它们已经学会对图像进行分类,在某些情况下甚至超过了人类...
  • 环境:python3.6版本 + TensorFlow 1.6版本 import os from PIL import Image import numpy as np import tensorflow as tf data_dir = r'E://data/data' # 数据文件夹 train = True # 训练还是测试 model_path ...
  • 使用卷积神经网络(U-net)进行视网膜血管分割该存储库包含用于对视网膜眼底图像中的血管进行分割的卷积神经网络的实现。 这是使用卷积神经网络(U-net)进行的二进制cl视网膜血管分割。该存储库包含用于对视网膜...
  • 项目要求:利用卷积神经网络来对电报报文进行识别,因为报文数据集较小,需要用到MNIST数据集来作为训练集。实现步骤:1. 数据预处理:将报文图片处理成单个数字2. 网络训练3. 网络参数微调4. 分类预测一. 数据...
  • 卷积神经网络,也叫convnet,它是计算机视觉应用几乎都在使用的一种深度 学习模型。 1.使用CNN对MNIST 数字进行分类 下列代码将会展示一个简单的卷积神经网络。 (1)Conv2D 层和MaxPooling2D 层的堆叠 from keras ...
  • 各种癌症类型的皮肤病变... 本文介绍了各种皮肤癌中皮肤病变的分类,然后将卷积神经网络的增量方法应用于皮肤镜图像。 本文使用了国际皮肤成像协作 (ISIC) 2018 挑战数据集。 本文中使用的程序产生了 90.26% 的准确率。
  • 基于Tensorflow和Keras实现卷积神经网络——猫狗分类环境搭建猫狗数据集猫狗分类的实例——基准模型 环境搭建 1.安装 Anaconda 教程百度有很多,这里就不详细写了。 2.配置tensorflow、keras a.创建虚拟环境 conda ...
  • 利用之前训练好的词向量,基于keras使用1D卷积神经网络完成文本分类任务准备工作 1:训练好的词向量 2:用于训练的文本(已完成分词,每篇文章且还有对应的label)from __future__ import print_function ...
  • 对于卷积神经网络(CNN)而言,相信很多读者并不陌生,该网络近年来在大多数领域都表现优异,尤其是在计算机视觉领域中。但是很多工作人员可能直接调用相关的深度学习工具箱搭建卷积神经网络模型,并不清楚其中具体...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 690
精华内容 276
关键字:

python卷积神经网络分类

python 订阅