[TensorFlow] Python 从基础到项目学习笔记No.3

最新推荐文章于 2024-10-02 10:53:34 发布
最新推荐文章于 2024-10-02 10:53:34 发布
阅读量206 收藏 2
点赞数
分类专栏： TensorFlow教程 文章标签： python TensorFlow 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qweqwrqw/article/details/90517175
版权

内容列表

TensorFlow 框架解决 MNIST 数字识别（一）

MNIST数据集一般是新手第一个接触的数据集，我目前也打算从这个数据集进一步了解TensorFlow的框架，开搞！

MNIST 数据处理

MNIST 是一个非常有名的手写体数字识别数据集， TensorFlow 的封装让使用 MNIST 数据集变得更加方便。 MNIST 数据集是 NIST 数据集的一个子集，它包含了 60000 张图片作为训练数据， 10000 张图片作为测试数据。在 MNIST 数据集中的每一张图片都代表了 0～9 中的一个数字。图片的大小都为 28x28 ， 且数字都会出现在图片的正中间。下图展示了一张数字图片对应的像素矩阵，右图为清楚展示，矩阵表示为14x14：

可以直接通过代码下载 MNIST 数据集，也可以自行在网站下载，下面是代码：

from tensorflow.examples.tutorials.mnist import input_data

# 载入 MNIST 数据集，如果指定地址./datasets/MNIST_data下没有已经下载好的数据，那么 TensorFlow 会自动下载数据。
mnist = input_data.read_data_sets('./datasets/MNIST_data/', one_hot=True)

print('Training data size:', mnist.train.num_examples)
print('Validating data size:', mnist.validation.num_examples)
print('Testing data size:', mnist.test.num_examples)
print('Example training data:', mnist.train.images[0])
print('Example training data label:', mnist.train.labels[0])
'''
输出为：
Training data size: 55000
Validating data size: 5000
Testing data size: 10000
Example training data: [0.  0.  0.  0.8235295  0.9803922  0.9960785 ...]
Example training data label: [0. 0. 0. 0. 0. 0. 0. 1. 0. 0.]
'''

这样，在文件夹中就会下载好使用的数据：

可以通过 mnist.train.next_batch 函数从所有的训练数据中读取一小部分作为一个训练 batch：

batch_size = 100
xs, ys = mnist.train.next_batch(batch_size)
# 从 train 的集合中选取 batch_size 个训练数据。
print('X shape:', xs.shape)
print('Y shape:', ys.shape)
'''
输出为：
X shape: (100, 784)
Y shape: (100, 10)
'''

TensorFlow 训练神经网络

这里给出一个完整的训练模型，对 MNIST 数据进行处理，来看一看 TensorFlow 的操作细节吧：

import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data

# MNIST 数据集相关的常数
INPUT_NODE = 784                    # 输入层的节点数。对于 MNIST 数据集，这个就等于图片的像素。
OUTPUT_NODE = 10                    # 输出层的节点数。这个等于类别的数目。因为在 MNIST 数据集中需要区分的足0~9这10个数宇，所以这里输出层的节点数为10。

# 配置神经网络的参数。
LAYERl_NODE = 500                   # 隐藏层节点数。这里使用只有一个隐藏层的网络结构作为样例。这个隐藏层有 500 个节点。
BATCH_SIZE = 100                    # 一个训练 batch 中的训练数据个数。数字越小时，训练过程越接近随机梯度下降：数字越大时，训练越接近梯度下降。
LEARNING_RATE_BASE = 0.8            # 基础的学习率。
LEARNING_RATE_DECAY = 0.99          # 学习率的衰减率。
REGULARIZATION_RATE = 0.0001        # 描述模型复杂度的正则化项在损失函数中的系数。
TRAINING_STEPS = 30000              # 训练轮数。
MOVING_AVERAGE_DECAY = 0.99         # 滑动平均衰减率。

# 一个辅助函数，给定神经网络的输入和所有参数，计算神经网络的前向传播结果。在这里定义了一个使用 ReLU 激活函数的三层全连接神经网络。通过加入隐藏层实现了多层网络结构，
# 通过 ReLU 激活函数实现了去线性化。在这个函数中也支持传入用于计算参数平均值的类，这样方便在测试时使用滑动平均模型。
def inference(input_tensor, avg_class, weights1, biases1, weights2, biases2):
    # 当没有提供滑动平均类时，直接使用参数当前的取值。
    if avg_class == None:
        # 计算隐藏层的前向传播结果，这里使用了 ReLU 激活函数。
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights1) + biases1)

        # 计算输出层的前向传播结果。因为在计算损失函数时会一并计算 softmax 函数，
        # 所以这里不需要加入激活函数。而且不加入 softmax 不会影响预测结果。因为预测时
        # 使用的是不同类别对应节点输出值的相对大小，有没有 softmax 层对最后分类结果的
        # 计算没有影响。于是在计算整个神经网络的前向传播时可以不加入最后的 softmax 层。
        return tf.matmul(layer1, weights2) + biases2

    else:
        # 首先使用 avg_class.average 函数来计算得出变量的滑动平均值，然后再计算相应的神经网络前向传播结果。
        layer1 = tf.nn.relu(tf.matmul(input_tensor, avg_class.average(weights1)) + avg_class.average(biases1))

        return tf.matmul(layer1, avg_class.average(weights2) + avg_class.average(biases2))

# 训练模型的过程。
def train(mnist):
    x = tf.placeholder(tf.float32, [None, INPUT_NODE], name = 'x-input')
    y_ = tf.placeholder(tf.float32, [None, OUTPUT_NODE], name = 'y-input')

    # 生成隐藏层的参数。
    weights1 = tf.Variable(tf.truncated_normal([INPUT_NODE, LAYERl_NODE], stddev=0.1))
    biases1 = tf.Variable(tf.constant(0.1, shape=[LAYERl_NODE]))
    # 生成输出层的参数。
    weights2 = tf.Variable(tf.truncated_normal([LAYERl_NODE, OUTPUT_NODE], stddev=0.1))
    biases2 = tf.Variable(tf.constant(0.1, shape=[OUTPUT_NODE]))

    # 计算在当前参数下神经网络前向传播的结果。这里给出的用于计算滑动平均的类为 None, 所以的数不会使用参数的滑动平均值。
    y = inference(x, None, weights1, biases1, weights2, biases2)

    # 定义在储训练轮数的变量。这个变量不需要计算滑动平均值，所以这里指定这个变量为不可训练的变量 (trainable=Fasle)。在使用 TensorFlow 训练神经网络时，
    # －般会将代表训练轮数的变量指定为不可训练的参数。
    global_step = tf.Variable(0, trainable=False)

    # 给定滑动平均哀减率和训练轮数的变量，初始化滑动平均类。给定训练轮数的变量可以加快训练早期变量的更新速度。
    variable_averages = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)

    # 在所有代表神经网络参数的变量上使用滑动平均。其他辅助变量(比如 global_step )就不需要了。 tf.trainable_variables 返回的就是图上集合
    # GraphKeys.TRAINABLE VARIABLES 中的元索。这个集合的元索就是所有没有指定 trainable=False 的参数。
    variables_averages_op = variable_averages.apply(tf.trainable_variables())

    # 计算使用了滑动平均之后的前向传播结果。滑动平均不会改变变量本身的驭值，而是会维护一个影子变量来记录其滑动平均值。所以当需要使用这个滑动平均值时，
    # 需要明确调用 average 函数。
    average_y = inference(x, variable_averages, weights1, biases1, weights2, biases2)

    # 计算交叉熵作为刻画预测值和真实值之间差距的损失函数。这里使用了 TensorFlow 中提供的 sparse_softmax_cross_entropy_with_logits 函数来计算交叉熵。当分类
    # 问题只有一个正确答案时，可以使用这个函数来加速交叉熵的计算。MNIST 问题的图片中只包含了0~9中的一个数字，所以可以使用这个函数来计算交叉熵损失。这个函数的第一个
    # 参数是神经网络不包括 softmax 层的前向传播结果，第二个是训练数据的正确答案。因为标准答案是一个长度为 10 的一维数组，而该函数需要提供的是一个正确答案的数字，所以需
    # 要使川 tf.argmax 函数来得到正确答案对应的类别编号。
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))

    # 计算在当前batch中所有样例的交叉熵平均值。
    cross_entropy_mean = tf.reduce_mean(cross_entropy)

    # 计算 L2 正则化损失函数。
    regularizer = tf.contrib.layers.l2_regularizer(REGULARIZATION_RATE)
    # 计算模型的正则化损失。一般只计算神经网络边上权重的正则化损失，而不使用偏执项。
    regularization = regularizer(weights1) + regularizer(weights2)
    # 总损失等于交叉熵损失和正则化损失的和。
    loss = cross_entropy_mean + regularization
    # 设置指数哀减的学习率。
    learning_rate = tf.train.exponential_decay(LEARNING_RATE_BASE,  # 基础的学习率，随着迭代的进行，更新变量时使用的学习率在这个基础上递减。
                                               global_step,         # 当前迭代的轮数。
                                               mnist.train.num_examples / BATCH_SIZE,  # 过完所有的训练数据需耍的迭代次数。
                                               LEARNING_RATE_DECAY)                    # 学习率衰减速度 。

    # 使用 tf.train.GradientDescentOptimizer 优化算法来优化损失函数。注意这里损失函数包含了交叉熵损失和 L2 正则化损失。
    train_step = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss, global_step=global_step)

    # 在训练神经网络模型时，每过一遍数据既需要通过反向传播来更新神经网络中的参数，又要更新每一个参数的滑动平均值。为了一次完成多个操作，TensorFlow 提供了
    # tf.control_dependencies 和 tf.group 两种机制 。 下面两行程序和 train_op = tf.group(train_step, variables_averages_op)是等价的。
    with tf.control_dependencies([train_step, variables_averages_op]):
        train_op = tf.no_op(name = 'train')

    # 检验使用了滑动平均模型的神经网络前向传播结果是否正确。tf.argmax(average_y, 1)计算每一个样例的预测答案。其中 average_y 是一个 batch_size * 10 的二维数组，每一行
    # 表示一个样例的前向传播结果。tf.argmax 的第二个参数"1"表示选取最大值的操作仅在第一个维度中进行，也就是说，只在每一行选取最大值对应的下标。于是得到的结果是一个长度为
    # batch 的一维数组，这个一维数组中的值就表示了每一个样例对应的数字识别结果。tf.equal 判断两个张量的每一维是否相等，如果相等返回 True，否则返回 False。
    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
    # 这个运算首先将一个布尔型的数值转换为实数型，然后计算平均值。这个平均值就是模型在这一组数据上的正确率。
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    # 初始化会话并开始训练过程。
    with tf.Session() as sess:
        tf.global_variables_initializer().run()
        # 准备验证数据。一般在神经网络的训练过程中会通过验证数据来大致判断停止的条件和评判训练的效果。
        validate_feed = {x: mnist.validation.images, y_: mnist.validation.labels}

        # 准备测试数据。在真实的应用中见，这部分数据在训练时是不可的，这个数据只是作为模型优劣的最后评价标准。
        test_feed = {x: mnist.test.images, y_: mnist.test.labels}

        # 迭代地训练神经网络。
        for i in range(TRAINING_STEPS):
            # 每 1000 轮输出一次在验证数据集上的测试结果。
            if i % 1000 == 0:
                # 计算滑动平均模型在验证数据上的结果。因为 MNIST 数据集比较小，所以一次可以处理所有的验证数据。为了计算方便，本程序没有将验证数据划分为更
                # 小的 batch. 当神经网络棋型比较复杂或者验证数据比较大时，太大的 batch 会导致计算时间过长甚至发生内存溢出的错误。
                validate_acc = sess.run(accuracy, feed_dict=validate_feed)
                print('After %d training step(s), validation accuracy using average model is %g' % (i, validate_acc))

            # 产生这一轮使用的一个 batch 的训练数据，并运行训练过程。
            xs, ys = mnist.train.next_batch(BATCH_SIZE)
            sess.run(train_op, feed_dict={x: xs, y_: ys})

        # 在训练结束之后，在测试数据上检测神经网络模型的最终正确率。
        test_acc = sess.run(accuracy, feed_dict=test_feed)
        print('After %d training step(s), test accuracy using average model is %g' % (TRAINING_STEPS, test_acc))

# 主程序入口。
def main(argv=None):
    # 声明处理 MNIST 数据集的类，这个类在初始化时会自动下载数据。
    mnist = input_data.read_data_sets('./datasets/MNIST_data', one_hot=True)
    train(mnist)

# TensorFlow 提供的一个主程序入口，tf.app.run 会调用上面定义的 main 函数。
if __name__ == '__main__':
    tf.app.run()

'''
输出为：
Extracting ./datasets/MNIST_data\train-images-idx3-ubyte.gz
Extracting ./datasets/MNIST_data\train-labels-idx1-ubyte.gz
Extracting ./datasets/MNIST_data\t10k-images-idx3-ubyte.gz
Extracting ./datasets/MNIST_data\t10k-labels-idx1-ubyte.gz
After 0 training step(s), validation accuracy using average model is 0.0886
After 1000 training step(s), validation accuracy using average model is 0.9706
After 2000 training step(s), validation accuracy using average model is 0.9792
After 3000 training step(s), validation accuracy using average model is 0.9816
After 4000 training step(s), validation accuracy using average model is 0.9826
...
After 28000 training step(s), validation accuracy using average model is 0.986
After 29000 training step(s), validation accuracy using average model is 0.9852
After 30000 training step(s), test accuracy using average model is 0.9843
'''

这里我没有使用滑动平均，最后的准确率在98%左右。

可以看一下使用不同优化方式对模型的准确率影响，不同优化方式包括滑动平均，正则化。指数衰减学习率，隐藏层与激活函数：

还有两张图表示学习率与平均绝对梯度（所有参数梯度绝对值的平均数）和学习率之间的关系：

变量管理

之前使用的调用函数进行前向传播的函数为：

def inference(input_tensor, avg_class, weights1, biases1, weights2, biases2):

可以看到这个函数的参数中包括了神经网络中的所有参数，然而，当神经网络的结构更加复杂、参数更多时，就需要一个更好的方式来传递和管理神经网络中的参数了。之前创建变量使用的是 tf.Variable 函数，除了 tf.Variable 函数，TensorFlow 还提供了 tf.get_variable 函数来创建或者获取变量。当 tf.get_variable 用 于创建变量时，它和 tf.Variable 的功能是基本等价的 。以下代码给出了通过这两个函数创建同一个变量的样例：

v = tf.get_variable('v', shape=[1],
                    initializer=tf.constant_initializer(1.0))
v = tf.Variable(tf.constant(1.0, shape=[l]), name='v')

上面 tf.get_variable 的初始化函数其实和 tf.Variable 常量生成函数是一一对应的，下表可以看到各种初始化的参数：

其实 tf.get_variable 函数与 tf.Variable 函数最大的区别在于指定变量名称的参数。对于tf.Variable 函数， 变量名称是一个可选的参数，通过 name＝“v”的形式给出。但是对于tf.get_variable 函数，变量名称是一个必填的参数。tf.get_variable 会根据这个名字去创建或
者获取变量，下面代码会给你一个清晰的理解：

# 在名字为 foo 的命名空间内创建名字为 v 的变量。
with tf.variable_scope('foo'):
    v = tf.get_variable('v',[1], initializer=tf.constant_initializer(1.0))
# 因为在命名空间 foo 中已经存在名字为 v 的变量，所以以下代码将会报错：
with tf .variable_scope('foo'):
    v = tf.get_variable('v', [1])
'''
报错为：
ValueError: Variable foo/v already exists, disallowed. Did you mean to set reuse=True or reuse=tf.AUTO_REUSE in VarScope?
'''
# 在生成上下文管理器时，将参数 reuse 设置为 True，这样 tf.get_variable 函数将直接获取已经声明的变量。
with tf.variable_scope('foo', reuse=True):
    vl = tf.get_variable('v',[1])
    print(v == vl)
'''
输出为：
True
'''
# 将参数 reuse 设置为 True 时， tf.variable_scope 将只能获取已经创建过的变量。因为在命名空间 bar 中还没有创建变量 v ，所以以下代码将会报错：
with tf. variable_scope('bar', reuse=True):
    v = tf.get_variable('v',[1])
'''
报错为：
ValueError: Variable bar/v does not exist, or was not created with tf.get_variable(). Did you mean to set reuse=tf.AUTO_REUSE in VarScope?
'''

TensorFlow 中 tf.variable_scope 函数是可以嵌套的。下面的程序说明了当 tf.variable_scope 函数嵌套时，reuse 参数的取值是如何确定的：

with tf.variable_scope('root'):
# 可以通过 tf.get_variable_scope().reuse 函数来获取当前上下文管理器中 reuse 参数的取值。
    print(tf.get_variable_scope().reuse)
    '''
	输出为：
	Fasle
	即最外层 reuse 是 False 。
	'''
    with tf.variable_scope('foo',reuse=True): # 新建一个嵌套的上下文管理器，并指定 reuse 为 True 。
        print(tf.get_variable_scope().reuse)
        '''
		输出为：
		True
		'''
        with tf.variable_scope('bar'):  # 新建一个嵌套的上下文管理器但不指定 reuse，这时 reuse的取值会和外面一层，保持一致 。
            print(tf.get_variable_scope().reuse)
            '''
			输出为：
			True
			'''
    print(tf.get_variable_scope().reuse)
	'''
	输出为：
	Fasle
	退出 reuse 设置为 True 的上下文之后 reuse 的值又回到了 False 。
	'''

tf.variable_scope 函数生成的上下文管理器也会创建一个 TensorFlow 中的命名空间，在命名空间内创建的变量名称都会带上这个命名空间名作为前缀。所以，tf.variable_scope 函数除了可以控制 tf.get_variable 执行的功能，这个函数也提供了一个管理变量命名空间的方式。以下代码显示了如何通过 tf.variable_ scope 来管理变量的名称：

v1 = tf.get_variable('v', [1])
print(v1.name) 
'''
输出为：
v:0
'v'为变量的名称，‘:0’表示这个变量是生成变量这个运算的第一个结果。
'''
with tf.variable_scope('foo'):
    v2 = tf.get_variable('v',[1])
    print(v2.name)
    '''
	输出为：
	foo/v:O
	在 tf.variable_scope 中创建的变量，名称前面会加入命名空间的名称，并通过/来分隔命名空间的名称和变量的名称。
	'''
with tf.variable_scope('foo'):
    with tf.variable_scope('bar'):
        v3 = tf.get_variable('v', [1])
        print(v3.name)
        '''
		输出为：
		foo/bar/v:O
		命名空间可以嵌套，问时变量的名称也会加入所有命名空间的名称作为前缀。
		'''
    v4 = tf.get_variable('v1', [1])
    print(v4.name)
    '''
	输出为：
	foo/v1:O
	当命名空间退出之后，变盘名称也就不会再被加入其前缀了。
	''' 
# 创建一个名称为空的命名空间，并设置 reuse=True 。
with tf.variable_scope('', reuse=True):
    v5 = tf.get_variable('foo/bar/v',[1]) # 可以直接通过带命名空间名称的变量名来获取其他命名空间下的变量。
    									  # 比如这里通过指定名称foo/bar/v来获取在命名空间foo/bar/中创建的变量。
    print(v5 == v3)
    '''
	输出为：
	True
	'''
    v6 = tf.get_variable('foo/v1', [1])
    print(v6 == v4)
    '''
	输出为：
	True
	'''

通过 tf.variable_scope 和 tf.get_variable 函数，以下代码对之前定义的计算前向传播结果的函数 inference() 做了 一些改进：

def inference(input_tensor, reuse=False):
	# 定义第一层神经网络的变量和前向传播过程。
    with tf.variable_scope('layer1', reuse=reuse):
        # 根据传进来的 reuse 来判断是创建新变量还是使用已经创建好的。在第一次构造网
        # 络时需要创建新的变量，以后每次调用这个函数都直接使用 reuse=True 就不需要每次将变量传进米了。
        weights = tf.get_variable('weights', [INPUT_NODE, LAYERl_NODE],
                                  initializer=tf.truncated_normal_initializer(stddev=0.1))
        biases = tf.get_variable('biases',[LAYERl_NODE],
                                  initializer=tf.constant_initializer(0.0))
        layer1 = tf.nn.relu(tf.matmul(input_tensor, weights) + biases)
	# 类似地定义第二层神经网络的变量和前向传播过程。
    with tf.variable_scope('layer2', reuse=reuse):
        weights = tf.get_variable('weights', [LAYER1_NODE, OUTPUT_NODE],
                                  initializer=tf.truncated_normal_initializer(stddev=0.1))
        biases = tf.get_variable('biases', [OUTPUT_NODE],
                                 initializer=tf.constant_initializer(0.0))
        layer2 = tf.matmul(layer1, weights) + biases
    # 返回最后的前向传播结果。
    return layer2
x = tf.placeholder(tf.float32, [None, INPUT_NODE], name='x-input')
y =inference(x)
# 在程序中需要使用训练好的神经网络进行推导时，可以直接调用 inference(new_x, True)。
# 如果需要使用滑动平均模型可以参考之前使用的代码，把计算滑动平均的类传到 inference 函数中即可。获取或者创建变量的部分不需要改变。
new_x = ...
new_y = inference(new_x, True)

小结

  1. 通过完整的 TensorFlow 程序展示了前向传播与反向传播的过程，虽然只有一层隐藏层，但是效果是极为显著的，并且注意各种优化方式的使用方法，尤其是正则化，激活函数与学习率衰减。
  2. 通过变量管理这个小节了解变量过多的情况下怎样简化传播方式。
gogogo！
关注
专栏目录
Tensorflow基础代码报错学习笔记3——Variable变量
7Starx的代码小屋
01-19 326
原教程地址之Variable变量 先贴原代码 import tensorflow as tf tf.compat.v1.disable_eager_execution()#这一句为了让run正常运行 state = tf.Variable(0,name='counter') #print(state.name) one = tf.constant(1) new_value = tf.add(state,one) update = tf.assign(state,new_value) #定义变量后最重
tensorflow学习笔记（使用 tf.data 加载文本数据）
DNDAW的博客
09-08 851
本文章是对tf.data.TextLineDataset的学习理解以及详细的学习笔记。内涵tensorflow加载文本的流程图。
TensorFlow和深度学习入门教程（TensorFlow and deep learning without a PhD）
热门推荐
Xianming的专栏
04-04 2万+
前言上月导师在组会上交我们用tensorflow写深度学习和卷积神经网络，并把其PPT的参考学习资料给了我们， 这是codelabs上的教程：《TensorFlow and deep learning,without a PhD》 当然登入需要翻墙，我也顺带巩固下，做个翻译，不好之处请包含指正。当然需要安装python，教程推荐使用python3。如果是Mac，可以参考博主的另外两片博文，Mac下
[TensorFlow] Python 从基础到项目学习笔记No.1
沉梦昂志丶
04-29 391
刚刚做完一个项目，使用的Keras+TensorFlow框架，但是主题语言大多是用Keras写的，因为Keras封装的很好，总觉得写起来比较简单，想系统的学习一个主流框架的使用方式，目前主流框架有TensorFlow、Pytorch、Caffe等等，经过多方面考虑，打算系统学习TensorFlow，大打下较好的基础，从今天开始！ 内容列表TensorFlow环境搭建TensorFlow入门介绍...
[TensorFlow] Python 从基础到项目学习笔记No.2
沉梦昂志丶
05-07 252
内容列表TensorFlow搭建深层神经网络TensorFlow内置激活函数TensorFlow损失函数经典损失函数分类问题回归问题自定义损失函数TensorFlow神经网络优化算法学习率的设置防止过拟合小结 TensorFlow搭建深层神经网络 鉴于之前彻底的讲过神经网络的具体内容，本笔记就不过多赘述神经网络的构造了，只针对TensorFlow内部算法与函数介绍。 TensorFlow内置激活函...
黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记
qq_44231797的博客
06-01 9670
黑马程序员3天带你玩转Python深度学习TensorFlow框架学习笔记
python学习笔记（33）----tensorflow安装的自闭之路---NO module named tensorflow.python.platform
b1348032123的博客
05-31 2130
安装tensorflow GPU版本中出现了很多问题，但是最后屈服选则了CPU版本之后，从 2.2一直安装到了1，能安的都试了个遍，就只剩下了几个问题,大多数网上都找到回答了，但是这个问了身边大佬才解决。 最后说下我踩的坑以及我认为最简单最小白的安装3步走。 首先最大的坑！！！，坑了我安装了各个版本的tensorflow，我一开始还 一直以为是版本没选对 NO module named ‘tensorflow.python.platform’ 这个问题大佬说是一开始安装没激活虚拟环境引起的调用路径冲突，反正
TensorFlow笔记：从零开始的代码实现
HgCH3的博客
04-22 806
这篇笔记包括了TensorFlow从读取数据开始，模型初始化和拟合，到使用TensorBoard查看结果的全流程。整理了一些常见的、包括版本更新引起的bug。
TensorFlow学习笔记
AI吃大瓜的博客
10-11 3621
TensorFlow学习笔记 目录 TensorFlow学习笔记 一、TF-slim库 1.TF-slim使用方法 一般网络定义方法 2. 常用模块实现 2.1 残差单元 2.2 dropout层 2.3 批规范化batch_norm 2.4 全局平局池化global average pooling 2.5 tf.losses 模块 2.5 正则化 2.6 滑动平均...
ubuntu18.04下搭建深度学习环境anaconda2+ cuda9.0+cudnn7.0.5+tensorflow1.7【原创】【学习笔记】...
zzb2760715357的博客
09-20 121
PC：ubuntu18.04、i5、七彩虹GTX1060显卡、固态硬盘、机械硬盘 作者：庄泽彬(欢迎转载，请注明作者) 说明:记录在ubuntu18.04环境下搭建深度学习的环境，之前安装了cuda9.1,与cudnn7.0.5版本的，但是无论怎么安装tensorflow-gpu都是失败，后来找到原因了，目前的tensorflow暂不支持cuda9.1,因此更换成cuda9.0,cudnn7.0...
Tensorflow基础代码报错学习笔记1——简单的神经网络
7Starx的代码小屋
01-18 719
@TOC 没有授权转载，只是如果大家想学习的话可以去b站看原视频 这个笔记是我跟着up主的教程打代码的时候遇到了一些问题（大部分是tensorflow版本问题）以及一些解决办法 先看原教程代码 （附部分up讲解的注释）***** import tensorflow as tf import numpy as np #create data# x_data = np.random.rand(100).astype(np.float32) y_data = x_data * 0.1 + 0.3 ###c
Tensorflow基础代码报错学习笔记4——Placeholder
7Starx的代码小屋
01-19 297
原视频教程 先贴原版代码（以及我的注释） import tensorflow as tf tf.compat.v1.disable_eager_execution() #一般只能处理float就默认写成float32就可以了# #如果输入的input是两行两列可以先规定结构： #input1 = tf.placeholder(tf.float32,[2,2])# input1 = tf.placeholder(tf.float32) input2 = tf.placeholder(tf.float32)
VeighNa：强大的Python开源量化交易平台
Unity打怪升级
09-26 731
VeighNa（简称 VN 或 vn.py）是一个基于 Python 的开源量化交易平台，专为量化交易爱好者和专业交易员设计。VeighNa 是由国内开发者社区推动的开源项目，旨在提供一个功能丰富、灵活且易于扩展的量化交易解决方案。该框架不仅支持多种资产类别的交易，如股票、期货、期权、加密货币等，还支持多种交易接口和协议，使得用户能够轻松进行多市场、多品种的交易策略开发和部署。
第二百五十四节 JPA教程 - JPA 多对多映射示例
2301_78772942的博客
09-27 716
第二百五十四节 JPA教程 - JPA 多对多映射示例
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
最新发布
haidizym的博客
10-02 357
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
python中的深浅拷贝以及总体框架了解
AgostoDu的博客
09-26 1189
1、当b使用copy.deepcopy()深拷贝的时候，可以理解为b不仅外面的整体开辟了一个新的内存地址，b里面包含的列表也开辟了新的内存地址和a里面的内存地址没有任何关系，所以当a修改里面列表元素的值时不会影响b里面列表元素的值。print(mr) #{'name': 'lis', 'age': 18, 'scroe': 100}<br>备注：已经存在的值的优先级>默认值<br>6.3 直接修改 值，显示最新修改值 （修改默认值优先级小于直接添加的字典值）<br>
遥感影像-实例分割数据集：iSAID 从切图到YOLO格式数据集制作详细介绍
GIS潮流
09-30 1017
开源数据集isaid标注包含实例分割，但是原始影像太大，很吃显存，一般显卡无法用原始影像直接训练，所以需要对影像进行裁剪，并生成对应的标签，因为想用yolo系列跑模型，所以将标签需要转为txt格式。
神经网络在多分类问题中的应用
小高~的博客
09-29 864
神经网络在分类任务中的应用越来越广泛，尤其是在图像识别、自然语言处理等领域。本文将介绍如何使用PyTorch构建一个简单的神经网络来处理多分类问题。我们将通过一个实战案例，展示数据构造、模型训练、模型保存与加载、以及评估结果的整个过程。
"Python深度学习TensorFlow框架学习笔记：3天快速入门
本文是一份关于学习Python深度学习TensorFlow框架的学习笔记。文章内容源自网址https://blog.csdn.net/qq_44231797/article/details/125086565。笔记共包括3天的学习内容，旨在带领读者快速入门并掌握TensorFlow框架...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值