tensorflow编程一般思路

最新推荐文章于 2020-11-23 13:53:31 发布
最新推荐文章于 2020-11-23 13:53:31 发布
阅读量175 收藏
点赞数
原文链接：https://blog.csdn.net/jiongnima/article/details/78337783
版权

小白编程，时常看tf代码看得头痛，也没有自己的一点思路。今天就结合网上的一些资料以及我自己的一个代码，整理了一下tensorflow编程一般思路。

一般我们从GitHub上下载的tensorflow的代码文档，主要包含如下几个文件：

在这里插入图片描述

  1. 训练与测试数据集文件夹datasets；
  2. 保存的模型文件夹snapshots；
  3. 数据传输接口image_reader.py；
  4. 网络定义文件net.py；
  5. 训练主控文件train.py；
  6. 测试主控文件evaluate.py；
  7. 辅助文件utils.py；

下面简单地概述一下每个文档的大概作用。

1.datasets

这个文档里面就是存放训练和测试的数据集，包括train_dataset和test_dataset两个文件夹，记录了训练与测试图片；另外还有两个train_data.txt和test_data.txt文档，记录了对于所有训练与测试图片的索引，作用是给数据传送接口调用。对于txt文件可以使用python编写(比如用上图中的write_txt.py和write_test_txt.py撰写训练/测试数据集索引)，索引的内容也可自己定制。一般直接添加图片和对应标签的名字，使用空格分离。

2.snapshots

训练完成后，模型会保存在这个文件夹下。同时在进行测试时，会对这个文件夹里面的模型参数进行读取。

3.image_reader.py

一般不采用tensorflow的官方数据传送接口，而是根据用户自己定义。如下列出一个我自己的文件。

import os
import numpy as np
import cv2

def ImageReader(file_name, picture_path, label_path, picture_format=".png", label_format=".jpg", size=256):
    picture_name = picture_path + file_name + picture_format  # 得到图片名称和路径
    label_name = label_path + file_name + label_format  # 得到标签名称和路径
    picture = cv2.imread(picture_name, 1)  # 读取图片
    label = cv2.imread(label_name, 1)  # 读取标签
    height = picture.shape[0]  # 得到图片的高
    width = picture.shape[1]  # 得到图片的宽
    picture_resize_t = cv2.resize(picture, (size, size))  # 调整图片的尺寸，改变成网络输入的大小
    picture_resize = picture_resize_t / 127.5 - 1.  # 归一化图片
    label_resize_t = cv2.resize(label, (size, size))  # 调整标签的尺寸，改变成网络输入的大小
    label_resize = label_resize_t / 127.5 - 1.  # 归一化标签
    return picture_resize, label_resize, height, width  # 返回网络输入的图片，标签，还有原图片和标签的长宽

在进行ImageReader定制的过程中，往往结合train_data.txt，从外存中读取数据，再送入网络进行迭代，用户可根据自己的需求进行各式各样的定制。

4. net.py

很多GitHub上的代码都把网络定义单独写一个.py文件，这是因为训练/测试主控程序是一个层次较高的代码，在进行实验的时候是不关心神经网络的具体细节的。因此，网络定义的细节应该是定义在net.py文件中。在进行net.py的撰写中，网络底层代码与网络高层代码相互分离，网络高层代码调用网络底层代码。

那么，何谓网络高层代码，何谓网络底层代码？网络高层代码协定了网络的设计架构，而网络底层代码则制约了网络底层(比如神经网络层)的规范。在训练主控代码中，程序只调用网络高层代码。对于高层代码与底层代码的封装，如下我的net.py文件中的部分代码：

import numpy as np
import tensorflow as tf
import math

# 构造可训练参数
def make_var(name, shape, trainable=True):
    return tf.get_variable(name, shape, trainable=trainable)

############################底层部分#############################
# 卷积层
def conv2d(input_, output_dim, kernel_size, stride, padding="SAME", name="conv2d", biased=False):
    input_dim = input_.get_shape()[-1]
    with tf.variable_scope(name):
        kernel = make_var(name='weights', shape=[kernel_size, kernel_size, input_dim, output_dim])
        output = tf.nn.conv2d(input_, kernel, [1, stride, stride, 1], padding=padding)
        if biased:
            biases = make_var(name='biases', shape=[output_dim])
            output = tf.nn.bias_add(output, biases)
        return output
        
# 空洞卷积层
def atrous_conv2d(input_, output_dim, kernel_size, dilation, padding="SAME", name="atrous_conv2d", biased=False):
    input_dim = input_.get_shape()[-1]
    with tf.variable_scope(name):
        kernel = make_var(name='weights', shape=[kernel_size, kernel_size, input_dim, output_dim])
        output = tf.nn.atrous_conv2d(input_, kernel, dilation, padding=padding)
        if biased:
            biases = make_var(name='biases', shape=[output_dim])
            output = tf.nn.bias_add(output, biases)
        return output
        
# 反卷积层
def deconv2d(input_, output_dim, kernel_size, stride, padding="SAME", name="deconv2d"):
    input_dim = input_.get_shape()[-1]
    input_height = int(input_.get_shape()[1])
    input_width = int(input_.get_shape()[2])
    with tf.variable_scope(name):
        kernel = make_var(name='weights', shape=[kernel_size, kernel_size, output_dim, input_dim])
        output = tf.nn.conv2d_transpose(input_, kernel, [1, input_height * 2, input_width * 2, output_dim],
                                        [1, 2, 2, 1], padding="SAME")
        return output



############################高层部分#############################
# 生成器，采用UNet架构，主要由8个卷积层和8个反卷积层组成
def generator(image, gf_dim=64, reuse=False, name="generator"):
    input_dim = int(image.get_shape()[-1])  # 获取输入通道
    dropout_rate = 0.5  # 定义dropout的比例
    with tf.variable_scope(name):
        if reuse:
            tf.get_variable_scope().reuse_variables()
        else:
            assert tf.get_variable_scope().reuse is False
			
        # 第一个卷积层，输出尺度[1, 128, 128, 64]
        e1 = batch_norm(conv2d(input_=image, output_dim=gf_dim, kernel_size=4, stride=2, name='g_e1_conv'),
                        name='g_bn_e1')
        # 第二个卷积层，输出尺度[1, 64, 64, 128]
        e2 = batch_norm(conv2d(input_=lrelu(e1), output_dim=gf_dim * 2, kernel_size=4, stride=2, name='g_e2_conv'),
                        name='g_bn_e2')
        # 第三个卷积层，输出尺度[1, 32, 32, 256]
        e3 = batch_norm(conv2d(input_=lrelu(e2), output_dim=gf_dim * 4, kernel_size=4, stride=2, name='g_e3_conv'),
                        name='g_bn_e3')
        # 第四个卷积层，输出尺度[1, 16, 16, 512]
        e4 = batch_norm(conv2d(input_=lrelu(e3), output_dim=gf_dim * 8, kernel_size=4, stride=2, name='g_e4_conv'),
                        name='g_bn_e4')
        # 第五个卷积层，输出尺度[1, 8, 8, 512]
        e5 = batch_norm(conv2d(input_=lrelu(e4), output_dim=gf_dim * 8, kernel_size=4, stride=2, name='g_e5_conv'),
                        name='g_bn_e5')
        # 第六个卷积层，输出尺度[1, 4, 4, 512]
        e6 = batch_norm(conv2d(input_=lrelu(e5), output_dim=gf_dim * 8, kernel_size=4, stride=2, name='g_e6_conv'),
                        name='g_bn_e6')
        # 第七个卷积层，输出尺度[1, 2, 2, 512]
        e7 = batch_norm(conv2d(input_=lrelu(e6), output_dim=gf_dim * 8, kernel_size=4, stride=2, name='g_e7_conv'),
                        name='g_bn_e7')
        # 第八个卷积层，输出尺度[1, 1, 1, 512]
        e8 = batch_norm(conv2d(input_=lrelu(e7), output_dim=gf_dim * 8, kernel_size=4, stride=2, name='g_e8_conv'),
                        name='g_bn_e8')

        # 第一个反卷积层，输出尺度[1, 2, 2, 512]
        d1 = deconv2d(input_=tf.nn.relu(e8), output_dim=gf_dim * 8, kernel_size=4, stride=2, name='g_d1')
        d1 = tf.nn.dropout(d1, dropout_rate)  # 随机扔掉一般的输出
        d1 = tf.concat([batch_norm(d1, name='g_bn_d1'), e7], 3)
        # 第二个反卷积层，输出尺度[1, 4, 4, 512]
        d2 = deconv2d(input_=tf.nn.relu(d1), output_dim=gf_dim * 8, kernel_size=4, stride=2, name='g_d2')
        d2 = tf.nn.dropout(d2, dropout_rate)  # 随机扔掉一般的输出
        d2 = tf.concat([batch_norm(d2, name='g_bn_d2'), e6], 3)
        # 第三个反卷积层，输出尺度[1, 8, 8, 512]
        d3 = deconv2d(input_=tf.nn.relu(d2), output_dim=gf_dim * 8, kernel_size=4, stride=2, name='g_d3')
        d3 = tf.nn.dropout(d3, dropout_rate)  # 随机扔掉一般的输出
        d3 = tf.concat([batch_norm(d3, name='g_bn_d3'), e5], 3)
        # 第四个反卷积层，输出尺度[1, 16, 16, 512]
        d4 = deconv2d(input_=tf.nn.relu(d3), output_dim=gf_dim * 8, kernel_size=4, stride=2, name='g_d4')
        d4 = tf.concat([batch_norm(d4, name='g_bn_d4'), e4], 3)
        # 第五个反卷积层，输出尺度[1, 32, 32, 256]
        d5 = deconv2d(input_=tf.nn.relu(d4), output_dim=gf_dim * 4, kernel_size=4, stride=2, name='g_d5')
        d5 = tf.concat([batch_norm(d5, name='g_bn_d5'), e3], 3)
        # 第六个反卷积层，输出尺度[1, 64, 64, 128]
        d6 = deconv2d(input_=tf.nn.relu(d5), output_dim=gf_dim * 2, kernel_size=4, stride=2, name='g_d6')
        d6 = tf.concat([batch_norm(d6, name='g_bn_d6'), e2], 3)
        # 第七个反卷积层，输出尺度[1, 128, 128, 64]
        d7 = deconv2d(input_=tf.nn.relu(d6), output_dim=gf_dim, kernel_size=4, stride=2, name='g_d7')
        d7 = tf.concat([batch_norm(d7, name='g_bn_d7'), e1], 3)
        # 第八个反卷积层，输出尺度[1, 256, 256, 3]
        d8 = deconv2d(input_=tf.nn.relu(d7), output_dim=input_dim, kernel_size=4, stride=2, name='g_d8')
        return tf.nn.tanh(d8)

在上述代码的网络底层代码中，规定了卷积、空洞卷积和转置卷积操作的定义，里面分别使用了tf.nn.conv2d、tf.nn.atrous_conv2d和tf.nn.conv2d_transpose接口，而网络高层代码看不见tensorflow的网络层接口。在高层代码中，制定了网络的具体架构，如上所示，定义了一个采用8个卷积层和8个反卷积层组成的生成器，而训练主控程序就调用net函数。从net中也可以方便地看出网络架构，并使得训练主控程序简洁明了。

这样做还有一个好处，就是在参数设置方面。注意到tensorflow的权重参数名称设置，在构造训练代码中，tf.get_variable(name, )和with tf.variable_scope(name)中的name是相当重要的。因为在tensorflow中，参数名称是按照类似堆栈的架构一级一级由底往上堆叠的，而每一次添加scope中的name就组成了堆栈的一部分。因此，如果说要满足同一个网络有两套不同的参数，又不需重新定义网络结构，应该怎么做呢？就将参数名称堆栈的栈顶换掉就行了，而栈顶以下的部分是不需要改动的。在网络定义文件中，网络高层代码和网络底层代码共同完成了对参数名称堆栈的除栈顶以外部分的定义与约束，而参数的栈顶部分则可以在训练主控程序中定制，这样就可以实现同一网络结构配置多套参数。并且，代码更加层次分明！

5. 训练主控文件train.py

对于训练的主控程序，首先往往需要在其中定义训练参数，这样方便在代码中修改。然后，可能需要一些输入占位符定义，其次最主要的是进行网络前向传播得到训练结果，并根据这个结果计算loss，之后需要使用训练器对网络进行反向传播并更新参数梯度。最后，根据需要导入fine-tune的参数，进行初始化，然后就是不停地送入数据并且进行网络的训练。

简而言之，训练的主控程序逻辑如下：

获取用户定义训练程序参数–>置占位符(placeholder)–>进行网络前向传播–>计算loss–>设置训练器并且进行网络反向传播–>保存sammary(可选)–>进行fine-tune参数的导入–>初始化训练过程–>传入数据进行网络训练。

from __future__ import print_function

#导入必要的库
import argparse
from random import shuffle
import os
import tensorflow as tf
import cv2
...

#导入自己写好的库
from image_reader import *
from net import *
...


#用户自定义训练参数
parser = argparse.ArgumentParser(description='')

parser.add_argument("--snapshot_dir", default='./snapshots', help="path of snapshots")
...
args = parser.parse_args()  # 用来解析命令行参数

##训练主函数
def main():
	if not os.path.exists(args.snapshot_dir):  # 如果保存模型参数的文件夹不存在则创建
        os.makedirs(args.snapshot_dir)
    if not os.path.exists(args.out_dir):  # 如果保存训练中可视化输出的文件夹不存在则创建
        os.makedirs(args.out_dir)
	
	#设置占位符
    image = tf.placeholder(tf.float32, shape=[1, args.image_size, args.image_size, image_channels],
                                   name='image')  # 输入的训练图像
    label = tf.placeholder(tf.float32, shape=[1, args.image_size, args.image_size, label_channels],
                                 name='label')  # 输入的与训练图像匹配的标签
	
	#进行网络前向传播
	net_output = net(image=image, reuse=False, name='net')
	
	#计算loss
	loss = comput_loss(image, label)
	
    #得到loss_summary(可选)
	loss_sum = tf.summary.scalar("loss", loss)
	summary_writer = tf.summary.FileWriter(args.snapshot_dir, graph=tf.get_default_graph())
	
	#设置训练器并进行网络训练，这里使用了一个Adam优化器
	vars = [v for v in tf.trainable_variables() if 'net' in v.name]
	optim = tf.train.AdamOptimizer(learning_rate)
	grads_and_vars = optim.compute_gradients(loss, var_list=vars)
	train_op = optim.apply_gradients(grads_and_vars)
	
	#设置tensorflow会话层
	config = tf.ConfigProto()
    config.gpu_options.allow_growth = True  # 设定显存不超量使用
    sess = tf.Session(config=config)  
	
	#进行fine-tune参数导入
	restore_vars = [v for v in tf.trainable_variables() if ...]#设置需要导入的参数
	loader = tf.train.Saver(var_list = restore_vars)
	loader.restore(sess, 'load parameters path')
		
	#初始化训练过程		
    init = tf.global_variables_initializer()  # 参数初始化器
    sess.run(init)  # 初始化所有可训练参数
		
	#保存器
	saver = tf.train.Saver(var_list=tf.global_variables(), max_to_keep=max_to_keep_nums)
	
	for step in range(training_steps):#进行网络训练
		load_image, load_label = ImageReader(image_path, step, ...)#按需传入读取图片的参数
		feed_dict = {image : load_image, label : load_label}
		oss_value, loss_sum_value, _= sess,run([loss, loss_sum, train_op], feed_dict = feed_dict)
		
		if step % add_summary_per_step == 0: #按需更新summary
			summary_writer.add_summary(loss_sum_value, loss)
		
		if step % save_per_step == 0: #按需保存模型参数
			saver.save(sess, 'save_path', step)
        print('...') #按需打印loss等

if __name__ == '__main__':
main()

在进行训练器设置并让网络自动求解梯度更新训练参数时，使用了两个接口：compute_gradients和apply_gradients，为什么要这么做呢？在进行参数更新的时候，先求解出参数和对应的梯度，然后可以按需对梯度做出转换，最后再利用改变的梯度来更新参数，这样可以有效地满足一些用户的自定制需求。

6. 测试主控文件evaluate.py

对于测试的程序，与训练主程序不同的地方是，测试程序并不需要计算loss和设置训练器进行网络参数的训练，当然也不需要保存summary。但是测试程序重要的是需要导入所需要的网络的全部参数（从snapshots文件中导入），这样网络才能完成前向传播过程，并且按需进行对结果的处理，测试精度，得到可视化效果等。

简而言之，测试的主控程序逻辑如下：

获取用户定义测试程序参数–>设置占位符(placeholder)–>进行网络前向传播得到结果–>进行前向传播所需参数的导入–>送数据进网络–>进行结果后处理

#导入必要的库
import argparse
import os
import tensorflow as tf
import cv2
...


#用户自定义训练参数
parser = argparse.ArgumentParser(description='')

parser.add_argument("--snapshot_dir", default='./snapshots', help="path of snapshots")
...
args = parser.parse_args()  # 用来解析命令行参数

#测试主函数
def main():
	if not os.path.exists(args.out_dir):  # 如果保存测试结果的文件夹不存在则创建
        os.makedirs(args.out_dir)

	#设置占位符
	image = tf.placeholder(tf.float32,shape=[1, image_height, image_height, image_channels],name='image')
	
	#进行网络前向传播
	net_output = net(image=image, reuse=False, name='net')
	
	#设置tensorflow会话层
	config = tf.ConfigProto()
    config.gpu_options.allow_growth = True  # 设定显存不超量使用
    sess = tf.Session(config=config)  # 建立会话层
	
	#进行测试所需参数导入
	restore_vars = [v for v in tf.global_variables() if ...] #设置测试需要导入的参数
	
	saver = tf.train.Saver(var_list=restore_var, max_to_keep=1)  # 导入模型参数时使用
    checkpoint = tf.train.latest_checkpoint(args.snapshots)  # 读取模型参数
    saver.restore(sess, checkpoint)  # 导入模型参数
	
	for step in range(testing_steps): #送入测试样本
		load_image, load_label = ImageReader(image_path, step, ...) #按需传入读取图片的参数
		feed_dict = {image : load_image, label : load_label}
		net_output = sess,run(net_output, feed_dict = feed_dict)
		result = postprocess(net_output) #进行后处理(可选)
		accuracy = compute_accuracy(result, label)#进行精度计算(可选)
		print('...') #按需打印信息等
	
if __name__ == '__main__':
main()

7. utils.py

utils.py文件往往就是一些中小型的tools，比如，经常将训练图像的前处理、后处理、数据转换等一些小型函数放在utils.py里面，起到一些辅助与查缺补漏的作用。如下我将save函数、l1和l2loss等写入其中。

import tensorflow as tf
import numpy as np 
import os 

def save(saver, sess, logdir, step):  # 保存模型的save函数
    model_name = 'model'  # 保存的模型名前缀
    checkpoint_path = os.path.join(logdir, model_name)  # 模型的保存路径与名称
    if not os.path.exists(logdir):  # 如果路径不存在即创建
        os.makedirs(logdir)
    saver.save(sess, checkpoint_path, global_step=step)  # 保存模型
    print('The checkpoint has been created.')
	
def l1_loss(src, dst):  # 定义l1_loss
    return tf.reduce_mean(tf.abs(src - dst))
	
def l2_loss(src, dst): #定义l2_loss
	return tf.reduce_mean((src - dst)**2)

本文章主要是在https://blog.csdn.net/jiongnima/article/details/78337783一文上编写的。个人写只为记录方便自己时常学习，如有侵权联系我立删。

挣脱惯性，换种人生
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【tensorflow基础学习】会话
Mosu_的专栏
10-12 338
会话--tensorflow运行模型 一、tensorflow系统结构的概述 从图中可以看出tensorflow的整个系统在结构上大体可以分为两个子系统—前端系统和后端系统。其中前端系统提供编程模型，负责构造计算图；后端系统提供运行时环境，负责执行计算图。 我们重点关注系统中Client、Distributed Master、work Services和Kernel Implements...
摆好正确姿势看Google神级深度学习框架TensorFlow的实践思路
02-24
本文来自于51cto，介绍了AlexNet的基本结构、Paper原理以及transformnetwork网络结构等相关知识。在2015年11月9号Google发布了人工智能系统TensorFlow并宣布开源，此举在深度学习领域影响巨大，也受到大量的深度学习开发者极大的关注。当然，对于人工智能这个领域，依然有不少质疑的声音，但不可否认的是人工智能仍然是未来发展的趋势。而TensorFlow能够在登陆GitHub的当天就成为最受关注的项目，作为构建深度学习模型的最佳方式、深度学习框架的领头者，在发布当周轻松获得超过1万个星数评级，这主要是因为Google在人工智能领域的研发成绩斐然和神级的技术人才
tensorflow 入门学习思路整理
03-01
tensorflow 入门学习思路整理 ，张量，回归算法，优化器，神经网络，激活函数 等等
tensorflow的会话
qq_39112101的博客
09-23 245
什么是会话？ 一个运行 TensorFlow operation 的类。tensorflow的底层是c++实现的，而上层调用使用的是python，所以在使用的时候中间环节需要使用到会话来作为中介，使用python来调用c++代码。 会话完整流程 1.会话初始化 2.会话执行op 3.关闭会话 placeholder起到占位的作用，与feed_dict在运行时共同使用，在运行时fe...
深度学习tensorflow框架的会话
weixin_42218868的博客
09-24 163
1、什么是会话？一个运行 TensorFlow operation 的类。tensorflow的底层是c++实现的，而上层调用使用的是python，所以在使用的时候中间环节需要使用到会话来作为中介，使用python来调用c++代码。 2、会话完整流程1.会话初始化 2.会话执行op 3.关闭会话 3、placeholder起到占位的作用，与feed_dict在运行时共同使用，在运行时feed...
基于TensorFlow.js的YOLOv5实时目标检测项目（源码+说明文档）.rar
04-15
2、代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 3、适用对象：计算机，电子信息工程、数学等专业的大学生课程设计和毕业设计。 4、更多仿真源码下载列表（自行寻找自己需要的）：...
基于Tensorflow实现YOLO目标检测模型（源码+运行说明）.rar
04-11
代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 适用对象：工科生、数学专业、算法等方向学习者。 作者介绍：某大厂资深算法工程师，从事Matlab、Python、C/C++、Java、YOLO算法仿真工作10年...
基于tensorflow开发的YOLO和YOLO9000，提供训练以及测试功能，以VOC2012数据集作为训练/测试集（5000
最新发布
12-27
2、代码特点：内含运行结果，不会运行可私信，参数化编程、参数可方便更改、代码编程思路清晰、注释明细，都经过测试运行成功，功能ok的情况下才上传的。 3、适用对象：计算机，电子信息工程、数学等专业的大学生...
基于tensorflow实现YOLO目标检测算法（源码+图片+说明文档）.rar
04-11
代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 适用对象：工科生、数学专业、算法等方向学习者。 作者介绍：某大厂资深算法工程师，从事Matlab、Python、C/C++、Java、YOLO算法仿真工作10年...
基于Tensorflow实现YOLOv3目标检测算法可对20个类物体检测（源码+说明文档）.rar
04-11
代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 适用对象：工科生、数学专业、算法等方向学习者。 作者介绍：某大厂资深算法工程师，从事Matlab、Python、C/C++、Java、YOLO算法仿真工作10年...
Tensorflow学习大致思路和步骤
hfut天天的博客
10-07 715
Tensorflow机器学习记录tensorflow处理结构计算图纸张量（Tensor):例1Session会话控制Variable 变量Placeholder 传入值激励函数 (Activation Function)非线性方程激励函数常用选择添加层 def add_layer()定义 add_layer()建造神经网络导入数据搭建网络训练matplotlib 可视化加速神经网络训练 (Spee...
tensorflow 一些方法的总结
咸蛋超人的CSDN博客
08-06 675
目录 tf.nn.l2_normalize的使用 按例计算 按行计算 tf.nn.embedding_lookup： tf.contrib.layers.xavier_initializer tf.reduce_mean() tf.reduce_sum tf.transpose()  转置 tf.reshape() tf.nn.l2_normalize的使用 tf.nn.l2...
Tensorflow学习系列(一): tensorflow解决问题的思路
vs412237401的博客
03-13 6533
如需转载，请注明出处，欢迎加入深度学习群 255568483 Tensorflow的介绍请各位自行google，就不做多的介绍了。 Tensorflow是一个深度学习框架，他和机器学习一样，有其固定的解决问题的方式。其训练过程有固定的模式，一般如下： 1.初始化模型参数 2.输入训练数据 3.在训练数据上验证模型 4.计算损失 5.调整模型参数 重复第2步操作。 解释： 1.在
深度学习最全优化方法总结比较及在tensorflow实现
u010899985的博客
08-19 8710
梯度下降算法针对凸优化问题原则上是可以收敛到全局最优的，因为此时只有唯一的局部最优点。而实际上深度学习模型是一个复杂的非线性结构，一般属于非凸问题，这意味着存在很多局部最优点（鞍点），采用梯度下降算法可能会陷入局部最优，这应该是最头疼的问题。这点和进化算法如遗传算法很类似，都无法保证收敛到全局最优。因此，我们注定在这个问题上成为“高级炼丹师”。可以看到，梯度下降算法中一个重要的参数是学习速率，适当...
Tensorflow一个程序的完整实现思路
格子衫的博客
02-21 594
1.configuration(FLAGS)----尽量将一些参数定义在一起，便于调参 2.load_data()-------加载数据包括处理数据的各种方法，切分数据集，形成训练集、测试集 3.create_session() (1)实例化模型（create graph） （a）设置超参数 （b）为x，y设置placeholder （c）实例化权重（embedding layer）(d)...
python3.6.5安装tensorflow_tensorflow（一）windows 10 python3.6安装tensorflow1.4与基本概念解读...
weixin_39647186的博客
11-23 368
一.安装目前用了tensorflow、deeplearning4j两个深度学习框架，tensorflow 之前一直支持到python 3.5,目前以更新到３.６，故安装最新版体验使用。慢慢长征路：安装过程如下ＷＩＮ１０：anaconda3.5:PYTHON3.6:tensorflow1.4:二.TensorFlow 基本概念与原理理解１.TensorFlow 的工作原理TensorFlow是用数据...
理解Tensorflow的编程模式
爱吃冰淇凌的羊驼
03-25 601
在编程模式中一般有两种编程模式 1.命令式编程：容易理解，命令语句基本无优化，例如 a=b+c 2.符号式编程：涉及较多的嵌入和优化，运行速度有同比提升，用计算流图来表示,上面的语句则可变为: b=tf.constant(1) c=tf.constant(2) a=tf.add(b,c) Tensorflow数据模型：Tensor(张量) Tensorflow数据流图的构成：数据...
详解GAN代码之搭建并详解CGAN代码
热门推荐
jiongnima的博客
05-05 3万+
训练数据集：填充轮廓->建筑照片下载链接：https://pan.baidu.com/s/1xUg8AC7NEXyKebSUNtRvdg 密码：2kw1   CGAN是Conditional Generative Adversarial Nets的缩写，也称为条件生成对抗网络。条件生成对抗网络指的是在生成对抗网络中加入条件(condition)，条件的作用是监督生成对抗网络。本篇博客通过简单...
tensorflow保存和恢复模型的两种方法介绍
fly_time2012的专栏
09-28 1万+
一、前言 本文将会介绍tensorflow保存和恢复模型的两种方法，一种是传统的Saver类save保存和restore恢复方法，还有一种是比较新颖的SavedModelBuilder类的builder保存和loader文件里的load恢复方法。通过了解这两种方法，我们可以解决如何保存和恢复一个已经训练好的神经网络模型用于推理预测的现实需求，也可以辅助查看分析一个长时间训练的模型性能，最重要的是...
tensorflow文档
06-23
API文档覆盖了TensorFlow的各个模块和类，让开发者能够编写高效和高质量的代码，而代码示例则提供了实际应用的代码片段和思路，让开发者可以快速实现自己的深度学习模型。 另外，TensorFlow文档还提供了许多关于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值