TensorFlow—学习笔记

最新推荐文章于 2022-04-16 18:22:38 发布

studyeboy

最新推荐文章于 2022-04-16 18:22:38 发布

阅读量418

点赞数

文章标签： TensorFlow

本文链接：https://blog.csdn.net/studyeboy/article/details/89840390

版权

tf.keras

Keras官方文档

Keras第三方文档
Keras是一个用Python编写的高级神经网络API，它能够以TensorFlow，CNTK或者Theano作为后端运行。Keras的开发重点是支持快速的实验。
Keras特点：

允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
同时支持卷积神经网络和循环神经网络，以及两者的组合。
在CPU和GPU上无缝运行。
兼容的Python版本：Python2.7-3.6
keras没有特定格式的单独配置文件。模型定义在Python代码中，这些代码紧凑，易于调试，并且易于扩展。
keras的核心数据结构是model，一种组织网络层的方式。最简单的O型是Sequenntial顺序模型，它由多个网络层线性堆叠。对于更复杂的结构，使用keras函数式API，它允许构建任意的神经网络图。

Conv2D层

二维卷积层，即对图像的空域卷积。该层对二维输入进行滑动窗卷积，当使用该层作为第一层时，应提欧共input_shape参数。例如input_shape=（128,128,3）代表128*128的彩色RGB图像（data_format=‘channels_last’）

keras.layers.convolutional.Conv2D(filters, kernel_size, strides=(1, 1), padding='valid', data_format=None, dilation_rate=(1, 1), activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None)

参数：

filters：卷积核的数目（即输出的维度）
kernel_size：单个整数或由两个整数构成的list/tuple，卷积核的宽度和长度。如果为单个整数，则表示在各个空间维度的相同长度。
strides：单个整数或由两个整数构成的list/tuple，为卷积的步长。如为单个整数，则表示在各个空间维度的相同步长。任何不为1的strides均与任何不为1的dilation_rate均不兼容
padding：补0策略，为“valid”，“same”。“valid”代表只进行有效的卷积，即对边界数据不处理。“same”代表保留边界处的卷积结果，通常会导致输出shape与输入shape相同。
activation：激活函数，为预定义的激活函数名，或逐元素（element-wise）的Theano函数。如果不指定该函数，将不会使用任何激活函数（即使用线性激活函数：a(x)=x）
dilation_rate：单个整数或由两个个整数构成的list/tuple，指定dilated convolution中的膨胀比例。任何不为1的dilation_rate均与任何不为1的strides均不兼容。
data_format：字符串，“channels_first”或“channels_last”之一，代表图像的通道维的位置。该参数是Keras 1.x中的image_dim_ordering，“channels_last”对应原本的“tf”，“channels_first”对应原本的“th”。以128x128的RGB图像为例，“channels_first”应将数据组织为（3,128,128），而“channels_last”应将数据组织为（128,128,3）。该参数的默认值是~/.keras/keras.json中设置的值，若从未设置过，则为“channels_last”。
use_bias:布尔值，是否使用偏置项
kernel_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器
bias_initializer：权值初始化方法，为预定义初始化方法名的字符串，或用于初始化权重的初始化器。
kernel_regularizer：施加在权重上的正则项，为Regularizer对象
bias_regularizer：施加在偏置向量上的正则项，为Regularizer对象
activity_regularizer：施加在输出上的正则项，为Regularizer对象
kernel_constraints：施加在权重上的约束项，为Constraints对象
bias_constraints：施加在偏置上的约束项，为Constraints对象
输入shape
‘channels_first’模式下，输入形如（samples,channels，rows，cols）的4D张量

‘channels_last’模式下，输入形如（samples，rows，cols，channels）的4D张量

注意这里的输入shape指的是函数内部实现的输入shape，而非函数接口应指定的input_shape，请参考下面提供的例子。
输出shape
‘channels_first’模式下，为形如（samples，nb_filter, new_rows, new_cols）的4D张量

‘channels_last’模式下，为形如（samples，new_rows, new_cols，nb_filter）的4D张量

输出的行列数可能会因为填充方法而改变

BatchNormalization

在每一个批次的数据中标准化前一层的激活项，即，应用一个维持激活项平均值接近 0，标准差接近 1 的转换。

keras.layers.BatchNormalization(axis=-1, momentum=0.99, epsilon=0.001, center=True, scale=True, beta_initializer='zeros', gamma_initializer='ones', moving_mean_initializer='zeros', moving_variance_initializer='ones', beta_regularizer=None, gamma_regularizer=None, beta_constraint=None, gamma_constraint=None)

参数

axis：整数，需要标准化的轴（通常是特征轴）。例如，在 data_format=“channels_first” 的 Conv2D 层之后，在 BatchNormalization 中设置 axis=1。
momentum：移动均值和移动方差的动量。
epsilon：增加到方差的小的浮点数，以避免除以零。
center：如果为 True，把 beta 的偏移量加到标准化的张量上。如果为 False， beta 被忽略。
scale：如果为 True，乘以 gamma。如果为 False，gamma 不使用。当下一层为线性层（或者例如 nn.relu），这可以被禁用，因为缩放将由下一层完成。
beta_initializer： beta 权重的初始化方法。
gamma_initializer： gamma 权重的初始化方法。
moving_mean_initializer：移动均值的初始化方法。
moving_variance_initializer：移动方差的初始化方法。
beta_regularizer：可选的 beta 权重的正则化方法。
gamma_regularizer：可选的 gamma 权重的正则化方法。
beta_constraint：可选的 beta 权重的约束方法。
gamma_constraint：可选的 gamma 权重的约束方法。

输入尺寸
可以是任意的。如果将这一层作为模型的第一层，则需要指定 input_shape 参数（整数元组，不包含样本数量的维度）。

输出尺寸
与输入相同。

Activation

将激活函数应用于输出。

keras.layers.Activation(activation)

参数

activation：要使用的激活函数的名称 (详见: activations)，或者选择一个 Theano 或 TensorFlow 操作。

输入尺寸
任意尺寸。当使用此层作为模型中的第一层时，使用参数 input_shape （整数元组，不包括样本数的轴）。

输出尺寸
与输入相同。

DepthwiseConv2D

深度可分离2D卷积。深度可分离卷积包括仅执行深度空间卷积中的第一步（其分别作用于每个输入通道）。depth_multiplier参数控制深度步骤中每个输入通道生成多少个输出通道。

keras.layers.DepthwiseConv2D(kernel_size, strides=(1, 1), padding='valid', depth_multiplier=1, data_format=None, activation=None, use_bias=True, depthwise_initializer='glorot_uniform', bias_initializer='zeros', depthwise_regularizer=None, bias_regularizer=None, activity_regularizer=None, depthwise_constraint=None, bias_constraint=None)

参数

kernel_size：一个整数，或者2个整数表示的元组或列表，指明2D卷积窗口的高度和宽度。可以是一个整数，为所有空间维度指定相同的值。
strides：一个整数，或者2个整数表示的元组或列表，指明卷积眼高度和宽度方向的步长。可以是一个整数，为所有空间维度指定相同的值。指定任何stride值！=1与指定dilation_rate值！=1两者不兼容。
padding：“valid”或“same”（大小写敏感）。
depth_multiplier：每个输入通道的深度方向卷积输出通道的数量。深度方向卷积输出通道的总数将等于filterss_in * depth_multiplier。
data_format：字符串，channels_last（默认）或channels_first之一，表示输入中维度的顺序。channels_last对应输入尺寸为（batch，height，width，channels），channels_first对应输入尺寸为（batch， channels，height，width）。它默认为从Keras配置文件~/.keras/keras.json中找到的image_data_format值。如果从未设置它，将使用channels_last。
activation：要使用的激活函数。
use_bias：布尔值，该层是否使用偏置向量。
depthwise_initializer：运用到深度方向的核矩阵的初始化器。
bias_initializer：偏置向量的初始化器。
depthwise_regularizer：运用到深度方向的核矩阵的正则化函数。
bias_regularizer：运用到偏置向量的正则化函数。
activity_regularizer：运用到层输出（它的激活值）的正则化函数。
depthwise_constraint：运用到深度方向的核矩阵的约束函数。
bias_constraint：运用到偏置向量的约束函数。

输入尺寸

如果 data_format=‘channels_first’，输入 4D 张量，尺寸为 (batch, channels, rows, cols)。
如果 data_format=‘channels_last’，输入 4D 张量，尺寸为 (batch, rows, cols, channels)。

输出尺寸

如果 data_format=‘channels_first’，输出 4D 张量，尺寸为 (batch, filters, new_rows, new_cols)。
如果 data_format=‘channels_last’，输出 4D 张量，尺寸为 (batch, new_rows, new_cols, filters)。

由于填充的原因， rows 和 cols 值可能已更改。

GPU设置

import os
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" #保证程序中的GPU序号和硬件中的序号是相同的
os.environ['CUDA_VISIBLE_DEVICES'] = "0,1" 
os.environ['CUDA_VISIBLE_DEVICES'] = "" #屏蔽所有的GPU设备，只使用CPU
...
#按需使用GPU设置
#method 1
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
session = tf.Session(config=config)
#method 2
gpu_options = tf.GPUOptions(allow_growth=True)
session = tf.Session(config=tf.ConfigProto(gpu_options=gpu_options))
#method 3
session = tf.Session(config=tf.ConfigProto(tf.GPUOptions(allow_growth=True)))

tf.logging

tf.logging.set_verbosity(tf.logging.INFO)

# 函数
tf.logging.set_verbosity(tf.logging.INFO)
# 功能：将TensorFlow日志信息输出到屏幕
# 例子：
tf.logging.info('Training on %s set', FLAGS.train_split)
#输出：
INFO：tensorflow:Training on train set

TensorFlow与5个不同级别的日志信息。其严重性为调试DEBUG<信息INFO<警告WARN<错误ERROR<致命FATAL。默认情况下，TensorFlow在WARN的日志记录级别进行配置，在跟踪模型训练时，需要将级别调整为INFO日志记录级别。

tf.gfile

class GFile：没有线程锁定的文件I/O包装器

tf.gfile.MkDir（dirname）

#函数
tf.gfile.MkDir(dirname)
#功能：用名称“dirname”创建一个目录
#参数：dirname：字符串要创建的目录的名称。

tf.gfile.Glob(filename)

查找匹配pattern的文件并以列表的形式返回，filename可以是一个具体的文件名，也可以是包含通配符的正则表达式。

tf.app

tf.app.flags

tf.app.flags.DEFINE_xxx()添加命令行的可选参数，tf.app.FLAGS可以从对应的命令行取出参数。

flags = tf.app.flags
FLAGS = flags.FLAGS
flags.DEFINE_integer('train_batch_size', 8, 'The number of images in each batch during training.')
print (FLAGS.train_batch_size)

flags.mark_flag_as_required

flags.mark_flag_as_required(参数名)将对应的命令行参数标记为必需的。

flags.mark_flag_as_required('train_logdir')

tf.cast

tf.cast()函数的作用是执行TensorFlow中张量数据集类型转换，例如读入的图片如果是int8类型的，一般要在训练前把图像的数据格式转换为float32.

tf.cast(
x,#带转换的数据（张量）
dtype,#目标数据类型
name=None #可选参数，定义操作的名称
)

 processed_image = tf.cast(image, tf.float32)

tf.cond

在TensorFlow中，tf.cond()类似于c语言中的if…else…，用来控制数据流向。

tf.cond(pred, fn1, fn2, name=None)
# Return :either fn1() or fn2() based on the boolean predicate pred.(注意这里，也就是说'fnq'和‘fn2’是两个函数)

tf.lin_space(tf.linspace)

均分计算指令，在间隔中生成值。从一开始就生成num平均间隔值的序列。如果num>1，则序列中的值通过（stop-start）/（num-1）增加，因此最后是一个完全停止的。

tf.linspace(10.0, 12.0, 3, name="linspace") => [ 10.0  11.0  12.0]

tf.shape

返回输入张量的形状。

tf.shape(
input, #输入Tensor
name=None, #操作的名称
out_type=tf.int32 #操作的指定输出类型
)

t = tf.constant([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]])
tf.shape(t)  # [2, 2, 3]

在这里插入图片描述

tf.convert_to_tensor

将不同数据转换成张量。

import tensorflow as tf;
import numpy as np;
 
A = list([1,2,3])
B = np.array([1,2,3])
C = tf.convert_to_tensor(A)
D = tf.convert_to_tensor(B)
 
with tf.Session() as sess:
	print type(A)
	print type(B)
	print type(C)

# 输出

<type 'list'>
<type 'numpy.ndarray'>
<class 'tensorflow.python.framework.ops.Tensor'>
<class 'tensorflow.python.framework.ops.Tensor'>

tf.rank

返回TensorFlow张量的秩。张量的秩与矩阵的秩不一样，张量的秩是唯一选择张量的每个元素所需的索引数量，秩也被称为‘order’，‘degree’或‘ndims’。

tf.rank(
input,
name=None
)

# shape of tensor 't' is [2, 2, 3]
t = tf.constant([[[1, 1, 1], [2, 2, 2]], [[3, 3, 3], [4, 4, 4]]])
tf.rank(t)  # 3

tf.image.resize_images

tf.image.resize_images 总的接口
- tf.image.resize_area 具体的实现
- tf.image.resize_bicubic
- tf.image.resize_bilinear
- tf.image.resize_nearest_neighbor

tf.image.resize_images(
images, #shape为[batch,height,width,channels]的4-D图像张量或者shape为[height,width,channels]的3-D图像张量
size,#一个dtype为int32拥有两个元素的1-D张量，格式为[new_height, new_width]
methode,#resize使用的方法
align_corner=False #精确对准输入输出图像的四个角，默认为False不精确对准。
)
# return：dtype为float的3-D或4-D图像张量，其shape分别为[batch, new_height, new_width, channels]和[new_height, new_width, channels]

具体的不同实现图像缩放处理函数的接口参数都形如：

(image,#[batch, height, width, channels]的4-D格式
size,#一个dtype为int32拥有两个元素的1-D张量，格式为[new_height, new_width]
align_corners=False,
name=None #操作名称
)

tf.logical_or

在这里插入图片描述

tf.Assert

断言给定条件为真。

    image_rank_assert = tf.Assert(
        tf.logical_or(
            tf.equal(tf.rank(image), 3),
            tf.equal(tf.rank(image), 4)),
        ['Wrong image tensor rank.'])

tf.control_dependencies

此函数指定某些操作执行的依赖关系，返回一个控制依赖的上下文管理器。

    with tf.control_dependencies([image_rank_assert]):
         image -= pad_value

tf.identity

y = tf.identity(x)是一个op操作表示将x赋值给y。
在这里插入图片描述

tf.train.Scaffold

Scaffold是一个可以能自定义变量初始化的方式，可以被传进tf.estimator和tf.MonitoredTrainingSession里面，用于训练init_fn操作符和其他分布式的设置。

tf.train.Scaffold(init_fn=init_fn, summary_op=summary_op)

tf.data

在数据集框架中，每一个数据集代表一个数据的来源：数据可以是一个张量，一个TFRecord文件。一个文本文件，等等。由于训练数据通常无法全部写入内存中，从数据集中读取数据时通常需要使用一个迭代器按顺序进行读取，数据集也是计算图中的一个节点。

从一个张量中创建数据集

from_tensor_slices：表示从张量中获取数据。
make_one_shot_iterator()：表示只将数据读取一次，然后就抛弃这个数据了。

input_data = [1,2,3,4,5]
dataset = tf.data.Dataset.form_tensor_slices(input_data)
iterator = dataset.make_one_shot_iterator()
x = iterator.get_next()

dataset 的常用函数

dataset = dataset.map(parse)：map是在数据集中的最常用的操作，表示对数据集中的每一条数据都调用参数中指定的parse方法，对每一条数据处理后，map将处理后的数据包装成一个新的数据集后返回。搭配lambda函数是最常用形式

dataset = dataset.map(lambda x : preprocess_for_train(x, image_size, image_size, None))

dataset = dataset.shuffle(buffer_size)：buffle的机制是在内存缓冲区保存一个buffer_size条数据，每读入一条数据后，从这个缓冲区中随机选择一条数据进行输出，缓冲区的大小越大越好，随机的性能就越好，但是更耗费内存。
dataset = dataset.batch(batch_size)
dataset = dataset.repeat(N)：表示将数据复制N份
concatenate()：表示将两个数据集顺序连接起来
take(N)：从数据集中读取前N项数据
skip(N)：表示在数据集中跳过前N项数据
flap_map()：表示从多个数据集中轮流读取数据

TFRecord

TFRecord主要是为了记录数据的，为了更方便的建图，原来使用placeholder，每次需要feed_dict，使用TFRecord+Dataset可以直接吧数据读入操作当作一个图中的节点，不用每次都feed了。TFRecord以字典的方式进行数据的创建。

将数据写入TFRecord文件

创建一个writer

writer = tf.python_io.TFRecordWriter(filename)

创建存储类型

features=tf.train.Features(feature={
      'image/encoded': _bytes_list_feature(image_data),
      'image/filename': _bytes_list_feature(filename),
      'image/format': _bytes_list_feature(
          _IMAGE_FORMAT_MAP[FLAGS.image_format]),
      'image/height': _int64_list_feature(height),
      'image/width': _int64_list_feature(width),
      'image/channels': _int64_list_feature(3),
      'image/segmentation/class/encoded': (
          _bytes_list_feature(seg_data)),
      'image/segmentation/class/format': _bytes_list_feature(
          FLAGS.label_format),
  })

tf_feature转换成tf_example

serialized = example = tf.train.Example(features=features)

序列化

example.SerializeToString()

写入样本关闭文件

writer.write(serialized)
writer.close()

使用Dataset读取数据

从TFRecord文件创建TFRecordDataset

tf.data.TFRecordDataset(files, num_parallel_reads=2)

创建解析函数

def parse_function( example_proto):
    #只接受一个输入：example_proto，也就是序列化后的样本tf_serialized

#解析字典
features = {
        'image/encoded':
            tf.FixedLenFeature((), tf.string, default_value=''),#定长解析
        'image/filename':
            tf.FixedLenFeature((), tf.string, default_value=''),
        'image/format':
            tf.FixedLenFeature((), tf.string, default_value='jpeg'),
        'image/height':
            tf.FixedLenFeature((), tf.int64, default_value=0),
        'image/width':
            tf.FixedLenFeature((), tf.int64, default_value=0),
        'image/segmentation/class/encoded':
            tf.FixedLenFeature((), tf.string, default_value=''),
        'image/segmentation/class/format':
            tf.FixedLenFeature((), tf.string, default_value='png'),
    }

进行解析

#把序列化样本和解析字典送人函数里得到解析的样本
#解析后得到的parsed_example也是一个字典（key=feature名字，value=feature解析值）
parsed_features = tf.parse_single_example(example_proto, features)

在这里插入图片描述

执行解析函数
解析TFRecord文件中的所有记录，使用dataset的map方法

tf.data.TFRecordDataset(files, num_parallel_reads=2)
.map(parse_function, num_parallel_calls=2)
.map(preprocess_image, num_parallel_cells=2)

对dataset中进行shuffle

dataset = dataset.shuffle(buffer_size=100)

对数据进行复制

dataset = dataset.repeat()

对数据进行分批

dataset = dataset.batch(batch_size)

创建迭代器

dataset.make_one_shot_iterator()

获取样本

samples = iterator.get_next()

参考资料

studyeboy

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
TensorFlow—学习笔记

Keras模块Keras官方文档Keras第三方文档Keras是一个用Python编写的高级神经网络API，它能够以TensorFlow，CNTK或者Theano作为后端运行。Keras的开发重点是支持快速的实验。Keras特点：允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。同时支持卷积神经网络和循环神经网络，以及两者的组合。在CPU和GPU上无缝运行。兼容的P...
复制链接

扫一扫