【TensorFlow-windows】学习笔记三——实战准备

前言

因为学习TensorFlow的内容较多,如果只看API会很无聊,可以结合实例去学习。但是在构建基本的模型之前,需要学一些准备知识:数据读取、预处理、优化器、损失函数

国际惯例,参考网址:

TensorFlow中文社区

TensorFlow官方文档

如何选择优化器 optimizer

TensorFlow-Examples

TensorFlow中的Neural Network

TensorFlow中的Train

深入浅出Tensorflow(三):训练神经网络模型的常用方法

理解tf.train.slice_input_producer()和tf.train.batch()

此外,为了模拟现实数据集,这里将mnist手写数字数据集转换成图片格式存储,放一下网盘链接:链接:https://pan.baidu.com/s/1ugEy85182vjcXQ8VoMJAbg 密码:1o83

处理数据集

从文本文件读取图像数据

按照caffe的读取习惯,把图片的路径和标签全部用txt文本文件存储起来,即路径\图片名 标签的格式:

./mnist/train/5/5_1.png 5
./mnist/train/0/0_2.png 0
./mnist/train/4/4_3.png 4
./mnist/train/1/1_4.png 1

然后参考TensorFlow-Examples中的build_an_image_dataset 方法按照文本文件中存储的路径和标签去按行读取

imagepaths, labels = list(), list()
data = open(dataset_path, 'r').read().splitlines()
for d in data:imagepaths.append(d.split(' ')[0])labels.append(int(d.split(' ')[1]))

在TF中打乱数据以及分批

因为我们要用tensorflow处理数据,所以必须将这些文本转换成tensorflow能处理的形式

 # 转换为张量
imagepaths = tf.convert_to_tensor(imagepaths, dtype=tf.string)
labels = tf.convert_to_tensor(labels, dtype=tf.int32)

打乱数据

# 建立TF队列,打乱数据
image, label = tf.train.slice_input_producer([imagepaths, labels],shuffle=True)

这里看一下这个slice_input_producer函数:

tf.train.slice_input_producer(tensor_list,num_epochs=None,shuffle=True,seed=None,capacity=32,shared_name=None,name=None
)
  • 作用:为tensor_list中的每个Tensor建立切片
  • 部分参数:
    tensor_listTensor形式的列表,第一个维度必须相同
    num_epochs:每个切片创建多少次
    shuffle:打乱顺序

所以在打乱顺序的时候将此函数的shuffle参数设置成True即可

图片读取和处理

打乱数据路径以后,就可以读取了,tensorflow也提供了图像处理相关函数,这里列部分有用的:

  • 调整图像亮度:

    tf.image.adjust_brightness(image,delta
    )
  • 调整图像对比度:

    tf.image.adjust_contrast(images,contrast_factor
    )
  • 伽马校正:

    tf.image.adjust_gamma(image,gamma=1,gain=1
    )
  • 从中间向边缘裁剪图像:

    tf.image.central_crop(image,central_fraction
    )
  • 裁剪图片,分别是左上角纵坐标、横坐标,裁剪的高度、宽度:

    tf.image.crop_to_bounding_box(image,offset_height,offset_width,target_height,target_width
    )
  • 图像解码:将对应图像解码为uint8张量(还有对应编码的encode函数):

    1. tf.image.decode_bmp
    2. tf.image.decode_gif
    3. tf.image.decode_image
    4. tf.image.decode_jpeg
    5. tf.image.decode_png
  • 图像翻转:

    1. tf.image.flip_left_right左右翻转
    2. tf.image.flip_up_down上下翻转
    3. tf.image.rot90翻转90度,可自定义次数
    4. tf.image.transpose_image图像转置
  • 图像转换:

    1. tf.image.grayscale_to_rgb:灰度图转换为RGB
    2. tf.image.hsv_to_rgb:HSV图转换为RGB
    3. tf.image.rgb_to_grayscale:RGB转灰度图
    4. tf.image.rgb_to_hsv:RGB转HSV
    5. tf.image.rgb_to_yiq:RGB转YIQ
    6. tf.image.rgb_to_yuv:RGB转YUV
    7. tf.image.yiq_to_rgb:YIQ转RGB
    8. tf.image.yuv_to_rgb:YUV转RGB
  • 图像填充:

    tf.image.pad_to_bounding_box(image,offset_height,offset_width,target_height,target_width
    )

    在图像上面填充offset_height高度的0,在图像左边填充offset_width宽度的0,再按照最终目标宽度和高度在下边和右边填充图像。

  • 图像归一化:tf.image.per_image_standardization(image)

  • 图像大小调整

    tf.image.resize_images(images,size,method=ResizeMethod.BILINEAR,align_corners=False
    )

    其中插值方法有:

    AREA
    BICUBIC
    BILINEAR
    NEAREST_NEIGHBOR

    所以在图像预处理过程中,先按照路径读取图像以及解码,然后调整图像大小,归一化:

    
    # 读取数据image = tf.read_file(image)
    image = tf.image.decode_jpeg(image, channels=CHANNELS)# 将图像resize成规定大小image = tf.image.resize_images(image, [IMG_HEIGHT, IMG_WIDTH])# 手动归一化image = image * 1.0/127.5 - 1.0

创建批量数据

就一个函数:

tf.train.batch(tensors,batch_size,num_threads=1,capacity=32,enqueue_many=False,shapes=None,dynamic_pad=False,allow_smaller_final_batch=False,shared_name=None,name=None
)
  • 作用:利用队列的方法存储批数据
  • 部分参数:
    tensors:张量列表或者字典
    batch_size:批大小
    num_thread:并行入队,采用线程数
    capacity:整数,队列里面最多有多少个元素

在制作数据集中,直接这样:

 # 创建batch
X, Y = tf.train.batch([image, label], batch_size=batch_size,capacity=batch_size * 8,num_threads=4)

具体可以参考这篇博客的描述:TensorFlow 组合训练数据(batching)、TensorFlow 笔记(九):数据读取

TF中神经网络相关函数

这里需要注意的是tf.layerstf.nn中均有相关层的实现,它们之间的区别我也不太清楚,但是从网上的观点来看,大部分人认为前者是以后者作为后端的,具体分析可看:

tf.nn.conv2d vs tf.layers.conv2d

tensorflow学习:tf.nn.conv2d 和 tf.layers.conv2d

Neural Network

层相关

目前构建神经网络还是使用前者的吧:

average_pooling1d(...): 一维输入平均池化
average_pooling2d(...): 二维输入平均池化(比如图像)
average_pooling3d(...): 三维输入平均池化(比如立体)
batch_normalization(...): 批归一化
conv1d(...): 一维卷积
conv2d(...): 二维卷积
conv2d_transpose(...): 2D反卷积
conv3d(...): 三维卷积
conv3d_transpose(...): 三维转置卷积
dense(...): 全连接
dropout(...): 随机丢失神经元
flatten(...): 保存第一个维度去展平数据
max_pooling1d(...): 一维输入最大池化
max_pooling2d(...): 二维输入最大池化
max_pooling3d(...): 三维输入最大池化
separable_conv1d(...): 按照深度独立方法一维卷积
separable_conv2d(...): 按照深度独立方法二维卷积

激活函数和损失相关

tf.nn也不是完全没用,它存储了激活函数以及部分损失函数:

sigmoid(...): sigmoid激活函数
tanh(...): tanh激活函数
softplus(...): 激活函数 log(exp(features) + 1).
relu(...): ReLU激活函数
leaky_relu(...): Leaky ReLU 激活函数max(features,leak*features)
elu(...): ELU激活函数:features if features>0 else alpha*(e^features-1)
selu(...): scaled exponential linear: scale * alpha * (exp(features) - 1)
crelu(...): 关联ReLU激活函数
relu6(...): Rectified Linear 6: min(max(features, 0), 6).
softmax(...): softmax 激活函数(一般用于最后一层)
softsign(...): 激活函数 features / (abs(features) + 1).
dropout(...):神经元抑制ctc_loss(...): CTC (Connectionist Temporal Classification)损失
nce_loss(...):计算noise-contrastive estimation训练损失
l2_loss(...): L2 损失.
log_poisson_loss(...): log Poisson损失.
weighted_cross_entropy_with_logits(...): 加权交叉熵损失(默认已将features用softmax激活)
sparse_softmax_cross_entropy_with_logits(...): 计算logits 和 labels的稀疏交叉熵损失
softmax_cross_entropy_with_logits(...): 计算logits 和 labels的交叉熵损失(默认已将features用softmax激活)
softmax_cross_entropy_with_logits_v2(...):  计算logits 和 labels的交叉熵损失(默认已将features用softmax激活)
sigmoid_cross_entropy_with_logits(...): 经sigmoid 函数激活之后的交叉熵(默认已将features用softmax激活)moments(...): 计算输入数据的均值和方差.
normalize_moments(...): 基于sufficient statistics计算输入数据的均值和方差top_k(...): 返回最后一个维度的k个最大值和索引
in_top_k(...):查询目标值是否在k个预测值中
xw_plus_b(...): 计算 matmul(x, weights) + biases.
relu_layer(...): 计算 Relu(x * weight + biases).

这里几个地方需要注意:

  1. l2_loss损失函数:没有开方,并且只取一半output=12x2output=12∑x2
  2. xxx__with_logits:类似于这样的都是已经将输出用softmax激活,然后计算误差,相当于做了两步工作:softmax激活输出、计算其log值与原始标签的乘积的和,具体介绍戳这里

正则项

两种正则化方法,三种函数:

  • 一范式正则化:

    tf.contrib.layers.l1_regularizer(scale,scope=None
    )
  • 二范式正则化:

    tf.contrib.layers.l2_regularizer(scale,scope=None
    )
  • 两种范式一起用

    tf.contrib.layers.l1_l2_regularizer(scale_l1=1.0,scale_l2=1.0,scope=None
    )

最后要将正则化应用到权重中:

tf.contrib.layers.apply_regularization(regularizer,weights_list=None
)

TF中的训练方法

包含优化器、梯度计算、梯度裁剪、学习率及其衰减,参考这里

优化器

Optimizer
GradientDescentOptimizer
AdadeltaOptimizer
AdagradOptimizer
AdagradDAOptimizer
MomentumOptimizer
AdamOptimizer
FtrlOptimizer
ProximalGradientDescentOptimizer
ProximalAdagradOptimizer
RMSPropOptimizer

各种梯度优化器,注意他们是属于,对应有很多函数可调用,比如minimize

梯度计算

gradients
AggregationMethod
stop_gradient
hessians

梯度裁剪

clip_by_value
clip_by_norm
clip_by_average_norm
clip_by_global_norm
global_norm

学习率及其衰减

exponential_decay
inverse_time_decay
natural_exp_decay
piecewise_constant
polynomial_decay
cosine_decay
linear_cosine_decay
noisy_linear_cosine_decay

一般不用搞那么复杂,随便用两个就行:

  • 指数形式的衰减方法

    tf.train.exponential_decay(learning_rate,#初始学习率global_step,#非负,衰减指数decay_steps,#正数,衰减周期decay_rate,#衰减率staircase=False,#如果是True,就是离散形式的衰减name=None
    )
    '''
    decayed_learning_rate = learning_rate *decay_rate ^ (global_step / decay_steps)
    staircase是True的时候(global_step / decay_steps)转换为整数
    '''
  • 多项式衰减:

    tf.train.polynomial_decay(learning_rate,global_step,decay_steps,end_learning_rate=0.0001,power=1.0,cycle=False,name=None
    )

    其中的cycle参数是决定lr是否在下降后重新上升的过程。cycle参数的初衷是为了防止网络后期lr十分小导致一直在某个局部最小值中振荡,突然调大lr可以跳出注定不会继续增长的区域探索其他区域。

    cycle时的计算方法:

    global_step = min(global_step, decay_steps)
    decayed_learning_rate = (learning_rate - end_learning_rate) *(1 - global_step / decay_steps) ^ (power) +end_learning_rate

    有cycle时的计算方法:

    decay_steps = decay_steps * ceil(global_step / decay_steps)
    decayed_learning_rate = (learning_rate - end_learning_rate) *(1 - global_step / decay_steps) ^ (power) +end_learning_rate

一般使用流程

一般是先定义学习率,然后使用优化器最小化损失

比如使用指数衰减:

...
global_step = tf.Variable(0, trainable=False)
starter_learning_rate = 0.1
learning_rate = tf.train.exponential_decay(starter_learning_rate, global_step,100000, 0.96, staircase=True)
# Passing global_step to minimize() will increment it at each step.
learning_step = (tf.train.GradientDescentOptimizer(learning_rate).minimize(...my loss..., global_step=global_step)
)

比如使用多项式衰减

...
global_step = tf.Variable(0, trainable=False)
starter_learning_rate = 0.1
end_learning_rate = 0.01
decay_steps = 10000
learning_rate = tf.train.polynomial_decay(starter_learning_rate, global_step,decay_steps, end_learning_rate,power=0.5)
# Passing global_step to minimize() will increment it at each step.
learning_step = (tf.train.GradientDescentOptimizer(learning_rate).minimize(...my loss..., global_step=global_step)
)

这个global_step随着训练自增,具体可以看这里

用这段代码可以看出来:

import tensorflow as tf;  
import numpy as np;  
import matplotlib.pyplot as plt;  x = tf.placeholder(tf.float32, shape=[None, 1], name='x')
y = tf.placeholder(tf.float32, shape=[None, 1], name='y')
w = tf.Variable(tf.constant(0.0))global_steps = tf.Variable(0, trainable=False)
learning_rate = tf.train.exponential_decay(0.1, global_steps, 10, 2, staircase=False)
loss = tf.pow(w*x-y, 2)train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_steps)with tf.Session() as sess:sess.run(tf.initialize_all_variables())for i in range(10):sess.run(train_step, feed_dict={x:np.linspace(1,2,10).reshape([10,1]),y:np.linspace(1,2,10).reshape([10,1])})print (sess.run(global_steps))

注意,经常无需人工计算梯度然后apply到相关参数列表上,因为minimize已经包含这两步骤了。

简单例子

按照这个例子很容易利用CNN实现一个手写数字识别网络
先引入相关包以及定义数据相关信息

import tensorflow as tf
import osDATASET_PATH = './mnist/train_labels.txt' # the dataset file or root folder path.
N_CLASSES = 10 # 类别数
IMG_HEIGHT = 28 # 高
IMG_WIDTH = 28 # 宽
CHANNELS = 1 # 通道数

然后按照标签中定义的图片路径和标签,制作数据集:

def read_images(dataset_path, batch_size):imagepaths, labels = list(), list()data = open(dataset_path, 'r').read().splitlines()for d in data:imagepaths.append(d.split(' ')[0])labels.append(int(d.split(' ')[1]))# 转换为张量imagepaths = tf.convert_to_tensor(imagepaths, dtype=tf.string)labels = tf.convert_to_tensor(labels, dtype=tf.int32)# 建立TF队列,打乱数据image, label = tf.train.slice_input_producer([imagepaths, labels],shuffle=True)# 读取数据image = tf.read_file(image)image = tf.image.decode_jpeg(image, channels=CHANNELS)# 将图像resize成规定大小image = tf.image.resize_images(image, [IMG_HEIGHT, IMG_WIDTH])# 手动归一化image = image * 1.0/127.5 - 1.0# 创建batchX, Y = tf.train.batch([image, label], batch_size=batch_size,capacity=batch_size * 8,num_threads=4)return X, Y

设置网络参数

#网络参数
learning_rate = 0.001#学习率
num_steps = 100#迭代次数
batch_size = 128#每批大小
display_step = 100#显示调试信息
dropout = 0.75 # dropout保留比率
X, Y = read_images(DATASET_PATH, batch_size)#读取数据集

定义网络结构:

# 创建卷积模型
def conv_net(x, n_classes, dropout, reuse, is_training):# Define a scope for reusing the variableswith tf.variable_scope('ConvNet', reuse=reuse):# 第一层卷积conv1 = tf.layers.conv2d(x, 32, 5, activation=tf.nn.relu)# 最大池化conv1 = tf.layers.max_pooling2d(conv1, 2, 2)# 第二层卷积conv2 = tf.layers.conv2d(conv1, 64, 3, activation=tf.nn.relu)# 最大池化conv2 = tf.layers.max_pooling2d(conv2, 2, 2)# 拉成一维向量fc1 = tf.layers.flatten(conv2)# 全连接层fc1 = tf.layers.dense(fc1, 1024)# 应用dropoutfc1 = tf.layers.dropout(fc1, rate=dropout, training=is_training)# 输出out = tf.layers.dense(fc1, n_classes)# softmax输出out = tf.nn.softmax(out) if not is_training else outreturn out

定义训练网络和评估网络,并进行训练

#训练网络
logits_train = conv_net(X, N_CLASSES, dropout, reuse=False, is_training=True)
# 测试网络
logits_test = conv_net(X, N_CLASSES, dropout, reuse=True, is_training=False)# 定义损失和优化器
loss_op = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits_train, labels=Y))
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
train_op = optimizer.minimize(loss_op)# 评估模型
correct_pred = tf.equal(tf.argmax(logits_test, 1), tf.cast(Y, tf.int64))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))# 初始化变量
init = tf.global_variables_initializer()# 保存模型参数
saver = tf.train.Saver()# 开始训练
with tf.Session() as sess:coord=tf.train.Coordinator()# 初始化参数sess.run(init)# 数据集队列tf.train.start_queue_runners(sess=sess,coord=coord)# 循环训练for step in range(1, num_steps+1):if step % display_step == 0:# Run optimization and calculate batch loss and accuracy_, loss, acc = sess.run([train_op, loss_op, accuracy])print("Step " + str(step) + ", Minibatch Loss= " + \"{:.4f}".format(loss) + ", Training Accuracy= " + \"{:.3f}".format(acc))else:            sess.run(train_op)coord.request_stop()#请求线程结束coord.join()#等待线程结束print("Optimization Finished!")# 保存模型saver.save(sess, './cnn_mnist_model/my_tf_model')

结果

Step 100, Minibatch Loss= 0.1098, Training Accuracy= 0.969
Step 200, Minibatch Loss= 0.1070, Training Accuracy= 0.969
Step 300, Minibatch Loss= 0.0393, Training Accuracy= 1.000
Step 400, Minibatch Loss= 0.0688, Training Accuracy= 0.984
Step 500, Minibatch Loss= 0.0559, Training Accuracy= 0.992
Step 600, Minibatch Loss= 0.0433, Training Accuracy= 0.984
Step 700, Minibatch Loss= 0.0341, Training Accuracy= 0.992
Step 800, Minibatch Loss= 0.0309, Training Accuracy= 0.984
Step 900, Minibatch Loss= 0.0825, Training Accuracy= 0.969
Step 1000, Minibatch Loss= 0.0211, Training Accuracy= 1.000
Optimization Finished!

个人感觉相对于theano使用tensorflow的好处在于,无需自己写梯度优化了,创建模型貌似不用自己去挨个权重定义和初始化,这里就没针对每个卷积核定义变量和单独初始化,除此之外,没感觉有啥其它便利性了。
还有一个重要问题是,这个模型保存了以后,好像无法拿过来单独测试一张图片,因为这里没有函数提供额外输入,即使想调用logits_test来测试单张图片,也不好弄,因为X无法在重载模型后指定单张图片,所以还得改代码,后续再研究研究模型保存与载入。

后记

这一部分主要了解一下在TensorFlow中构建神经网络可以使用的部分函数。
我嘞个乖乖,感觉好难啊,跟Theano差不多,好底层,想脱坑转TensorLayer或者TFLearn这两个基于tensorflow的二次封装库,知乎上有对应讨论如何比较Keras, TensorLayer, TFLearn ?,貌似大部分人都推荐TL,先继续折腾TensorFlow的保存和加载模型,如果实在不行,后续去了解一下对工程实现的支持程度以及模型的保存和载入难度,再选择框架。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/246608.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

【TensorFlow-windows】学习笔记四——模型构建、保存与使用

前言 上一章研究了一些基本的构建神经网络所需的结构:层、激活函数、损失函数、优化器之类的,这一篇就解决上一章遗留的问题:使用CNN构建手写数字识别网络、保存模型参数、单张图片的识别 国际惯例,参考博客: tenso…

【TensorFlow-windows】学习笔记五——自编码器

前言 上一篇博客介绍的是构建简单的CNN去识别手写数字,这一篇博客折腾一下自编码,理论很简单,就是实现对输入数据的重构,具体理论可以看我前面的【theano-windows】学习笔记十三——去噪自编码器 国际惯例,参考博客&…

【TensorFlow-windows】学习笔记六——变分自编码器

#前言 对理论没兴趣的直接看代码吧,理论一堆,而且还有点复杂,我自己的描述也不一定准确,但是代码就两三句话搞定了。 国际惯例,参考博文 论文:Tutorial on Variational Autoencoders 【干货】一文读懂…

【TensorFlow-windows】学习笔记七——生成对抗网络

前言 既然学习了变分自编码(VAE),那也必须来一波生成对抗网络(GAN)。 国际惯例,参考网址: 论文: Generative Adversarial Nets PPT:Generative Adversarial Networks (GANs) Generative Adversarial Nets in TensorFlow GAN原理学习笔记…

Openpose——windows编译(炒鸡简单)

前言 最近准备看看rtpose的代码,发现已经由openpose这个项目维护着了,由于经常在windows下调试代码,所以尝试了一下如何在windows下编译openpose源码,整体来说非常简单的。 国际惯例,参考博客: [OpenPos…

【TensorFlow-windows】学习笔记八——简化网络书写

前言 之前写代码的时候都要预先初始化权重,还得担心变量是否会出现被重复定义的错误,但是看网上有直接用tf.layers构建网络,很简洁的方法。 这里主要尝试了不预定义权重,是否能够实现正常训练、模型保存和调用,事实证…

强化学习——Qlearning

前言 在控制决策领域里面强化学习还是占很重比例的,最近出了几篇角色控制的论文需要研究,其中部分涉及到强化学习,都有开源,有兴趣可以点开看看: A Deep Learning Framework For Character Motion Synthesis and Edit…

【TensorFlow-windows】keras接口学习——线性回归与简单的分类

前言 之前有写过几篇TensorFlow相关文章,但是用的比较底层的写法,比如tf.nn和tf.layers,也写了部分基本模型如自编码和对抗网络等,感觉写起来不太舒服,最近看官方文档发现它的教程基本都使用的keras API,这…

【TensorFlow-windows】keras接口——卷积手写数字识别,模型保存和调用

前言 上一节学习了以TensorFlow为底端的keras接口最简单的使用,这里就继续学习怎么写卷积分类模型和各种保存方法(仅保存权重、权重和网络结构同时保存) 国际惯例,参考博客: 官方教程 【注】其实不用看博客,直接翻到文末看我的c…

【TensorFlow-windows】keras接口——BatchNorm和ResNet

前言 之前学习利用Keras简单地堆叠卷积网络去构建分类模型的方法,但是对于很深的网络结构很难保证梯度在各层能够正常传播,经常发生梯度消失、梯度爆炸或者其它奇奇怪怪的问题。为了解决这类问题,大佬们想了各种办法,比如最原始的…

【TensorFlow-windows】keras接口——卷积核可视化

前言 在机器之心上看到了关于卷积核可视化相关理论,但是作者的源代码是基于fastai写的,而fastai的底层是pytorch,本来准备自己用Keras复现一遍的,但是尴尬地发现Keras还没玩熟练,随后发现了一个keras-vis包可以用于做…

【TensorFlow-windows】投影变换

前言 没什么重要的,就是想测试一下tensorflow的投影变换函数tf.contrib.image.transform中每个参数的含义 国际惯例,参考文档 官方文档 描述 调用方法与默认参数: tf.contrib.image.transform(images,transforms,interpolationNEAREST,…

【TensorFlow-windows】扩展层之STN

前言 读TensorFlow相关代码看到了STN的应用,搜索以后发现可替代池化,增强网络对图像变换(旋转、缩放、偏移等)的抗干扰能力,简单说就是提高卷积神经网络的空间不变性。 国际惯例,参考博客: 理解Spatial Transformer…

【TensorFlow-windows】部分损失函数测试

前言 在TensorFlow中提供了挺多损失函数的,这里主要测试一下均方差与交叉熵相关的几个函数的计算流程。主要是测试来自于tf.nn与tf.losses的mean_square_error、sigmoid_cross_entry、softmax_cross_entry、sparse_softmax_cross_entry 国际惯例,参考博…

RS编码-Python工具包使用

前言 最近学习二维码相关知识,遇到了ReedSolomon编码,简称RS编码,中文名里德所罗门编码。遇到的问题是使用的工具包返回的编码是bytearray类型,而二维码是二进制01编码,所以本博客主要验证,如何将bytearra…

【TensorFlow-windows】MobileNet理论概览与实现

前言 轻量级神经网络中,比较重要的有MobileNet和ShuffleNet,其实还有其它的,比如SqueezeNet、Xception等。 本博客为MobileNet的前两个版本的理论简介与Keras中封装好的模块的对应实现方案。 国际惯例,参考博客: 纵…

【TensorFlow-windows】keras接口——ImageDataGenerator裁剪

前言 Keras中有一个图像数据处理器ImageDataGenerator,能够很方便地进行数据增强,并且从文件中批量加载图片,避免数据集过大时,一下子加载进内存会崩掉。但是从官方文档发现,并没有一个比较重要的图像增强方式&#x…

【TensorFlow-windows】name_scope与variable_scope

前言 探索一下variable_scope和name_scope相关的作用域,为下一章节tensorboard的学习做准备 其实关于variable_scope与get_variable实现变量共享,在最开始的博客有介绍过: 【TensorFlow-windows】学习笔记二——低级API 当然还是国际惯例…

【TensorFlow-windows】TensorBoard可视化

前言 紧接上一篇博客,学习tensorboard可视化训练过程。 国际惯例,参考博客: MNIST机器学习入门 Tensorboard 详解(上篇) Tensorboard 可视化好帮手 2 tf-dev-summit-tensorboard-tutorial tensorflow官方mnist_…

深度学习特征归一化方法——BN、LN、IN、GN

前言 最近看到Group Normalization的论文,主要提到了四个特征归一化方法:Batch Norm、Layer Norm、Instance Norm、Group Norm。此外,论文还提到了Local Response Normalization(LRN)、Weight Normalization(WN)、Batch Renormalization(BR)…