TensorflowTutorial_二维数据构造简单CNN

使用二维数据构造简单卷积神经网络

觉得有用的话,欢迎一起讨论相互学习~Follow Me

图像和一些时序数据集都可以用二维数据的形式表现,我们此次使用随机分布的二位数据构造一个简单的CNN—网络卷积-最大池化-全连接

参考代码

# Implementing Different Layers
# ---------------------------------------
#
# We will illustrate how to use different types
# of layers in TensorFlow
#
# The layers of interest are:
#  (1) Convolutional Layer卷积层
#  (2) Activation Layer激活层
#  (3) Max-Pool Layer池化层
#  (4) Fully Connected Layer 全连接层
#
# We will generate two different data sets for this
#  script, a 1-D data set (row of data) and
#  a 2-D data set (similar to picture)
import tensorflow as tf
import matplotlib.pyplot as plt
import csv
import os
import random
import numpy as np
import random
from tensorflow.python.framework import ops

# ---------------------------------------------------|
# -------------------2D-data-------------------------|
# ---------------------------------------------------|

# Reset Graph 重置图模型
ops.reset_default_graph()
sess = tf.Session()

# parameters for the run 运行参数
row_size = 10  # 2D图形高
col_size = 10  # 2D图形长
conv_size = 2
conv_stride_size = 2  # 卷积步长
maxpool_size = 2
maxpool_stride_size = 1  # 池化步长

# ensure reproducibility 确保复现性
seed = 13
np.random.seed(seed)
tf.set_random_seed(seed)

# Generate 2D data生成随机二维数据
data_size = [row_size, col_size]
data_2d = np.random.normal(size=data_size)

# --------Placeholder--------
x_input_2d = tf.placeholder(dtype=tf.float32, shape=data_size)

# Convolution 卷积层
def conv_layer_2d(input_2d, my_filter, stride_size):
    # TensorFlow‘s ‘conv2d()‘ function only works with 4D arrays:
    # [batch, height, width, channels], we have 1 batch, and
    # 1 channel, but we do have width AND height this time.
    # So next we create the 4D array by inserting dimension 1‘s.
    # Tensorflow的卷积操作默认输入有四个维度[batch_size, height, width, channels]
    # 此处我们将维度增加到四维
    input_3d = tf.expand_dims(input_2d, 0)
    input_4d = tf.expand_dims(input_3d, 3)
    convolution_output = tf.nn.conv2d(input_4d, filter=my_filter,
                                      strides=[1, stride_size, stride_size, 1], padding="VALID")
    # filter表示卷积核,数据维度为[卷积核高度,卷积核长度,输入通道数,输出通道数]
    # stride_size表示步长,数据维度为[批处理数据大小,步长高,步长宽,通道数],其中批处理数据大小和通道数一般跨度都为1,不需要修改。
    # Get rid of unnecessary dimensions
    # 将维数为1的维度去掉,保留数值数据。
    conv_output_2d = tf.squeeze(convolution_output)
    return (conv_output_2d)

# Create Convolutional Filter
my_filter = tf.Variable(tf.random_normal(shape=[conv_size, conv_size, 1, 1]))
# Create Convolutional Layer
my_convolution_output = conv_layer_2d(x_input_2d, my_filter, stride_size=conv_stride_size)

# --------Activation--------
def activation(input_1d):
    return (tf.nn.relu(input_1d))

# Create Activation Layer 激活层
my_activation_output = activation(my_convolution_output)

# --------Max Pool--------
def max_pool(input_2d, width, height, stride):
    # Just like ‘conv2d()‘ above, max_pool() works with 4D arrays.
    # [batch_size=1, height=given, width=given, channels=1]
    input_3d = tf.expand_dims(input_2d, 0)
    input_4d = tf.expand_dims(input_3d, 3)
    # Perform the max pooling with strides = [1,1,1,1]
    # If we wanted to increase the stride on our data dimension, say by
    # a factor of ‘2‘, we put strides = [1, 2, 2, 1]
    pool_output = tf.nn.max_pool(input_4d, ksize=[1, height, width, 1],
                                 strides=[1, stride, stride, 1],
                                 padding=‘VALID‘)
    # Get rid of unnecessary dimensions
    pool_output_2d = tf.squeeze(pool_output)
    return (pool_output_2d)

# Create Max-Pool Layer 最大池化层
# 即选择窗口中的最大值作为输出,池化层的窗口格式定义和卷积核的不一样
# 其四维数组格式定义和卷积步长,池化步长一致,和输入格式相同,即
# [batch_size, height, width, channels]
my_maxpool_output = max_pool(my_activation_output,
                             width=maxpool_size, height=maxpool_size, stride=maxpool_stride_size)

# --------Fully Connected--------
def fully_connected(input_layer, num_outputs):
    # 扁平化/光栅化处理使最大池化层输出为一维向量形式
    flat_input = tf.reshape(input_layer, [-1])
    # 设定weight的形状
    weight_shape = tf.squeeze(tf.stack([tf.shape(flat_input), [num_outputs]]))
    # 初始化weight
    weight = tf.random_normal(weight_shape, stddev=0.1)
    # 初始化bias
    bias = tf.random_normal(shape=[num_outputs])
    # 将一维输入还原为二维
    input_2d = tf.expand_dims(flat_input, 0)
    # 计算输出
    full_output = tf.add(tf.matmul(input_2d, weight), bias)
    # 降维,去掉维度为1的维度,便于进行观察
    full_output_2d = tf.squeeze(full_output)
    return (full_output_2d)

# Create Fully Connected Layer
my_full_output = fully_connected(my_maxpool_output, 5)

# Run graph
# Initialize Variables
init = tf.global_variables_initializer()
sess.run(init)

feed_dict = {x_input_2d: data_2d}

print(‘\n>>>> 2D Data <<<<‘)

# Convolution Output
print(‘Input = %s array‘%(x_input_2d.shape.as_list()))
print(‘%s Convolution, stride size = [%d, %d] , results in the %s array‘%
      (my_filter.get_shape().as_list()[:2], conv_stride_size, conv_stride_size, my_convolution_output.shape.as_list()))
print(sess.run(my_convolution_output, feed_dict=feed_dict))

# Activation Output
print(‘\nInput = the above %s array‘%(my_convolution_output.shape.as_list()))
print(‘ReLU element wise returns the %s array‘%(my_activation_output.shape.as_list()))
print(sess.run(my_activation_output, feed_dict=feed_dict))

# Max Pool Output
print(‘\nInput = the above %s array‘%(my_activation_output.shape.as_list()))
print(‘MaxPool, stride size = [%d, %d], results in %s array‘%
      (maxpool_stride_size, maxpool_stride_size, my_maxpool_output.shape.as_list()))
print(sess.run(my_maxpool_output, feed_dict=feed_dict))

# Fully Connected Output 全连接层
print(‘\nInput = the above %s array‘%(my_maxpool_output.shape.as_list()))
# 全连接层输出除掉batch_size和channel维度后剩余维度为[4,4]
print(‘Fully connected layer on all %d rows results in %s outputs:‘%
      (my_maxpool_output.shape.as_list()[0], my_full_output.shape.as_list()[0]))
# 由于全连接层神经元为5个所以输出维度为5
print(sess.run(my_full_output, feed_dict=feed_dict))

‘‘‘对于卷积层输出维度[batch_size,output_size,output_size‘,channels]
其中output_size及output_size‘表示为对应维度上通过(W-F+2P)/S+1得到的结果
W为数据维度,F为卷积核或池化窗口的宽或高,P为Padding大小,其中设置卷积为Valid时,Padding为0若设置为SAME卷积,则会有Padding,S是步长大小
本例子中卷积层计算公式为[(10-2)+0]/2+1=5,池化层计算公式为[(5-2)+0]/1+1=4‘‘‘

# >>>> 2D Data <<<<
# Input = [10, 10] array
# [2, 2] Convolution, stride size = [2, 2] , results in the [5, 5] array
# [[ 0.14431179  0.72783369  1.51149166 -1.28099763  1.78439188]
#  [-2.54503059  0.76156765 -0.51650006  0.77131093  0.37542343]
#  [ 0.49345911  0.01592223  0.38653135 -1.47997665  0.6952765 ]
#  [-0.34617192 -2.53189754 -0.9525758  -1.4357065   0.66257358]
#  [-1.98540258  0.34398788  2.53760481 -0.86784822 -0.3100495 ]]
#
# Input = the above [5, 5] array
# ReLU element wise returns the [5, 5] array
# [[ 0.14431179  0.72783369  1.51149166  0.          1.78439188]
#  [ 0.          0.76156765  0.          0.77131093  0.37542343]
#  [ 0.49345911  0.01592223  0.38653135  0.          0.6952765 ]
#  [ 0.          0.          0.          0.          0.66257358]
#  [ 0.          0.34398788  2.53760481  0.          0.        ]]
#
# Input = the above [5, 5] array
# MaxPool, stride size = [1, 1], results in [4, 4] array
# [[ 0.76156765  1.51149166  1.51149166  1.78439188]
#  [ 0.76156765  0.76156765  0.77131093  0.77131093]
#  [ 0.49345911  0.38653135  0.38653135  0.6952765 ]
#  [ 0.34398788  2.53760481  2.53760481  0.66257358]]
#
# Input = the above [4, 4] array
# Fully connected layer on all 4 rows results in 5 outputs:
# [ 0.08245847 -0.16351229 -0.55429065 -0.24322605 -0.99900764]

参考文献

TensorFlow机器学习实战指南

原文地址:https://www.cnblogs.com/cloud-ken/p/8425368.html

时间: 2024-10-29 08:27:17

TensorflowTutorial_二维数据构造简单CNN的相关文章

TensorflowTutorial_一维数据构造简单CNN

使用一维数据构造简单卷积神经网络 觉得有用的话,欢迎一起讨论相互学习~Follow Me 神经网络对于一维数据非常重要,时序数据集.信号处理数据集和一些文本嵌入数据集都是一维数据,会频繁的使用到神经网络.我们在此利用一组一维数据构造卷积层-最大池化层-全连接层的卷积神经网络.希望给大家使用CNN处理一维数据一些帮助. 参考代码 # Implementing Different Layers # --------------------------------------- # # We will

二维数据名作形参

之前帮同学调一个程序的时候遇到的,把二维数据改为全局变量,不通过参数传递就没问题了,否则程序崩溃. 细究一下,二维数据名用于形参时需要注意哪些方面. 测试程序如下: #include<stdio.h> #include<stdlib.h> void print1(int **a, int m, int n); void print2(int (*a)[2], int m, int n); int main() { int a[2][2]={1,2,3,4}; print1((int

对二维数据进行边界拓展

对二维数据处理的时候,经常遇到需要越界的问题,比如对图像进行滤波操作.对原始数据的边界进行拓展,然后使用拓展后的数据作处理,可以解决越界的问题.根据拓展出的数据的值来自哪里可以分为多种边界拓展方式,我们要实现的是将边界进行奇对称拓展. 算法 举例说明什么是奇拓展.比如对原始二维数据向左拓展4列,那么在边界上向左第一列复制边界上向右第一列,在边界上向左第二列复制边界上向右第二列,以此类推.边界列并没有被复制,因为C语言中是从0开始计数的,所以边界列是0列,按照0列对称拓展就称为奇对称拓展.如果0列

【Excle数据透视】二维数据如何创建数据透视表

二维数据在创建数据透视表的时候,可能会给你带来一些麻烦,没法创建,会丢失维度,那怎么办呢? 解决办法:使用数据透视表和数据透视图向导即可创建 步骤1 按下[Alt+D+P],出现如下界面 选择上图中的"多重合并计算数据区域"→下一步 创建单页字段→下一步 选定区域A:A15→添加→下一步 单击完成 数据透视表已经创建完成.二维数据透视表与一维数据透视表在于"行合计" 注意:我上图的数据透视是使用默认计数,所以全部都是1,这个可以根据自己的需求进行调整.

PHP二维数据排序,二维数据模糊查询

一.因为项目中的一个报表需要合并三个表的数据,所以分表查询再合并数据,利用PHP数组函数进行排序,搜索.三表合并后的数组结构如下: Array ( [0] => Array ( [history_id] => 12 [sla_group_id] => 1 [sla_id] => -1 [create_time] => 1513057695 [tasklog_id] => 12 [tasklog_time] => 2017-12-12 13:48:15 [taskl

一维数据和二维数据

此文章为本人学习所得,如有不足之处,欢迎指正,分享原创,一起进步 维度:数据的组织形式 一维数据 由对等关系的有序或无序数据构成,采用线性方式(一条直线排开)组织 对等关系:这些数据平级关系(不是包含.从属关系) 一维数据的表示----- 如果数据间有序:使用列表类型.如:一维列表ls = [3.1 , 3.02 , 4.15]如果数据间无序:使用集合类型,如:一维集合st ={ 4.15 , 3.02 , 3.1} 切记:for循环可以遍历数据,进而对每个数据进行处理 一维数据的存储-----

python第七周,二维数据的格式化和处理

二维数据的表示: 类表类型可以表示二维数据 [   [424,23423,2342],[131,535,3646]  ] 使用两层for循环可以便利每个元素 外层列表中每个元素可以对应一行,也可以对应一列 一维数据分为列表和集合类型,二维数据只有列表类型 CSV数据存储格式 国际通用的一二维数据存储格式,一般.csv扩展名,每行一个一维数据,采用逗号分隔,无空行 Excel软件可读入输出,一般编辑软件都可以产生,如果某个元素缺失,逗号仍要保留, 二维数据的表头可以作为数据存储,也可以另行存储,

Swift 二维码扫描 简单实现

3.30看视频  学到了二维码简单的实现 还有一些动画的实现  今天就先记录一下二维码扫描的简单实现  不太好记手写一遍 学习的基础在于模仿嘛 创建一个实现二维码扫描的步骤 1.首先是懒加载创建 会话 输入设备  输出设备 // 先倒入框架 AVFoundation import AVFoundation //通过懒加载 创建输入设备 private lazy var deviceInput: AVCaptureDeviceInput? = { //获取设备摄像头 let device = AV

关于二维数据中的一维指针作为函数参数和返回值

问题描述: 1 假定定义了一个二维数组用来存放多条(总20条)数据,每条数据长度为10,uchar message[20][10] 2 要将外部来的一条数据存放到缓冲区指定位置(入口参数 uchar *p,数据的开始地址) 3 要从缓冲区读出一条记录,将其输出(出口参数 uchar *p,数据的开始地址). 那么该怎么写2个函数的形参/return值/返回值类型 答案: void sendbuf(uchar a[10]) { ...将a[0]~a[9]的值拷贝到指定缓冲区buf[i][0~9]