TensorFlow 基础知识笔记之队列和线程

最新推荐文章于 2020-08-23 19:39:01 发布
最新推荐文章于 2020-08-23 19:39:01 发布
阅读量2.1k 收藏 3
点赞数
分类专栏： 深度学习 文章标签： python 线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ggwcr/article/details/78017884
版权

TensorFlow 基础知识笔记之队列和线程

和 TensorFlow 中的其他组件一样， 队列（queue）本身也是图中的一个节点，是一种有状态的节点，其他节点，如入队节点（enqueue）和出队节点（dequeue），可以修改它的内容。例如，入队节点可以把新元素插到队列末尾，出队节点可以把队列
前面的元素删除。

环境：win7 64位 tensorflow1.3-gpu python3.5

队列

TensorFlow 中主要有两种队列，即 FIFOQueue 和 RandomShuffleQueue

FIFOQueue

FIFOQueue 创建一个先入先出队列。例如，我们在训练一些语音、文字样本时，使用循环神经网络的网络结构，希望读入的训练样本是有序的，就要用 FIFOQueue。

import tensorflow as tf

# 创建一个先入先出队列,初始化队列插入 0.1、 0.2、 0.3 三个数字
q = tf.FIFOQueue(3,"float")
init = q.enqueue_many(([0.1,0.2,0.3],))
# 定义出队、+1，入队操作
x = q.dequeue()   # 出队是从队首出，返回值为队首的元素
y = x+1
q_inc = q.enqueue([y])    # 入队是队尾

# 开启一个会话
with tf.Session() as sess:
    sess.run(init)
    for i in range(2):
        sess.run(q_inc)  # 执行 2 次操作，队列中的值变为 0.3,1.1,1.2

    quelen = sess.run(q.size())
    for i in range(quelen):
        print (sess.run(q.dequeue())) # 输出队列的值
0.3
1.1
1.2

RandomShuffleQueue

RandomShuffleQueue 创建一个随机队列，在出队列时，是以随机的顺序产生元素的。例如，我们在训练一些图像样本时，使用 CNN 的网络结构，希望可以无序地读入训练样本，就要用RandomShuffleQueue，每次随机产生一个训练样本。

RandomShuffleQueue 在 TensorFlow 使用异步计算时非常重要。因为 TensorFlow 的会话是支持多线程的，我们可以在主线程里执行训练操作，使用 RandomShuffleQueue 作为训练输入，开多个线程来准备训练样本，将样本压入队列后，主线程会从队列中每次取出 mini-batch 的样本进行训练。

import tensorflow as tf

# 创建一个随机队列，队列最大长度为 10，出队后最小长度为 2
q = tf.RandomShuffleQueue(capacity=10,min_after_dequeue=2,dtypes="float")

# 开启一个会话
sess = tf.Session()
for i in range(0,10):
    sess.run(q.enqueue(i))

for i in range(0,8):
    print(sess.run(q.dequeue()))
5.0
9.0
2.0
0.0
1.0
7.0
6.0
4.0

发现每一次执行的结果都不一样，说明确实是随机乱序的。

我们尝试修改入队次数为 12 次，再运行，发现程序阻断不动，或者我们尝试修改出队此时为 10 次，即不保留队列最小长度，发现队列输出 8 次结果后，在终端仍然阻断了。
阻断一般发生在：
● 队列长度等于最小值，执行出队操作；
● 队列长度等于最大值，执行入队操作。

可以通过设置绘画在运行时的等待时间来解除阻断：

run_options = tf.RunOptions(timeout_in_ms = 10000) # 等待 10 秒
try:
    sess.run(q.dequeue(), options=run_options)
except tf.errors.DeadlineExceededError:
    print('out of range')
out of range

队列管理器

上面的例子都是在会话的主线程中进行入队操作。当数据量很大时，入队操作从硬盘中读取数据，
放入内存中，主线程需要等待入队操作完成，才能进行训练操作。会话中可以运行多个线程，我们
使用线程管理器 QueueRunner 创建一系列的新线程进行入队操作，让主线程继续使用数据，即训
练网络和读取数据是异步的，主线程在训练网络，另一个线程在将数据从硬盘读入内存。

import tensorflow as tf

# 创建一个含有队列的图
q = tf.FIFOQueue(1000,"float")  # 创建一个长度为1000的队列
counter = tf.Variable(0.0)  # 计数器
increment_op = tf.assign_add(counter,tf.constant(1.0))   # 操作：给计数器加1
enqueque_op = q.enqueue(counter)  # 操作：计数器值加入队列

# 创建一个队列管理器 QueueRunner，用这两个操作向队列 q 中添加元素，启动一个线程。
qr = tf.train.QueueRunner(q,enqueue_ops=[increment_op,enqueque_op]*1)

# 启动一个会话，从队列管理器qr中创建线程

#主线程
with tf.Session() as sess:
    sess.run(tf.global_variables_initializer())
    enqueue_threads = qr.create_threads(sess,start=True)  # 启动入队线程

    #主线程
    for i in range(10):
        print(sess.run(q.dequeue()))
1.0
1.0
2.0
3.0
5.0
6.0
7.0
8.0
9.0
10.0
ERROR:tensorflow:Exception in QueueRunner: Run call was cancelled
ERROR:tensorflow:Exception in QueueRunner: Session has been closed.


Exception in thread Thread-22:
Traceback (most recent call last):
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\threading.py", line 914, in _bootstrap_inner
    self.run()
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\threading.py", line 862, in run
    self._target(*self._args, **self._kwargs)
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\site-packages\tensorflow\python\training\queue_runner_impl.py", line 238, in _run
    enqueue_callable()
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\site-packages\tensorflow\python\client\session.py", line 1245, in _single_tensor_run
    fetch_list_as_strings, [], status, None)
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\contextlib.py", line 66, in __exit__
    next(self.gen)
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\site-packages\tensorflow\python\framework\errors_impl.py", line 466, in raise_exception_on_not_ok_status
    pywrap_tensorflow.TF_GetCode(status))
tensorflow.python.framework.errors_impl.CancelledError: Run call was cancelled

Exception in thread Thread-23:
Traceback (most recent call last):
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\threading.py", line 914, in _bootstrap_inner
    self.run()
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\threading.py", line 862, in run
    self._target(*self._args, **self._kwargs)
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\site-packages\tensorflow\python\training\queue_runner_impl.py", line 238, in _run
    enqueue_callable()
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\site-packages\tensorflow\python\client\session.py", line 1235, in _single_operation_run
    target_list_as_strings, status, None)
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\contextlib.py", line 66, in __exit__
    next(self.gen)
  File "C:\Anaconda3\envs\tensorflow-gpu\lib\site-packages\tensorflow\python\framework\errors_impl.py", line 466, in raise_exception_on_not_ok_status
    pywrap_tensorflow.TF_GetCode(status))
tensorflow.python.framework.errors_impl.CancelledError: Session has been closed.

能输出结果，但最后会异常：

ERROR:tensorflow:Exception in QueueRunner: Run call was cancelled

ERROR:tensorflow:Exception in QueueRunner: Session has been closed.

我们知道，使用with tf.Session的话，会话执行结束会自动关闭，相当于main函数已经结束，
固也就有 Session has been closed.的错误。

import tensorflow as tf

# 创建一个含有队列的图
q = tf.FIFOQueue(1000,"float")  # 创建一个长度为1000的队列
counter = tf.Variable(0.0)  # 计数器
increment_op = tf.assign_add(counter,tf.constant(1.0))   # 操作：给计数器加1
enqueque_op = q.enqueue(counter)  # 操作：计数器值加入队列

# 创建一个队列管理器 QueueRunner，用这两个操作向队列 q 中添加元素，启动一个线程。
qr = tf.train.QueueRunner(q,enqueue_ops=[increment_op,enqueque_op]*1)

# 启动一个会话，从队列管理器qr中创建线程
# 主线程
sess = tf.Session()
sess.run(tf.global_variables_initializer())

enqueue_threads = qr.create_threads(sess,start=True)

# 主线程
for i in range(10):
    print(sess.run(q.dequeue()))
1.0
3.0
4.0
5.0
6.0
7.0
7.0
8.0
9.0
10.0

使用Session就不会自动关闭，也就没有了上面例子中的异常了，虽然没有了异常，但也和我们
设想的会打印顺序的1,2,3,4,5…不一样，而且像第一个例子中还会重复打印1.0，这是为什么呢？

这个本质是+1操作和入队操作是异步的，也就是说如果加1操作执行了很多次之后，才执行一次入队的话，就会出现入队不是按我们预想的顺序那样；反过来，当我执行几次入队之后，才执行一次加1操作就会出现一个数重复入队的情况。

那该怎么解决这个问题呢！下面为几种解决的方法

# 方法1
import tensorflow as tf

q = tf.FIFOQueue(1000,"float")  
counter = tf.Variable(0.0)  
increment_op = tf.assign_add(counter,tf.constant(1.0))  
enqueque_op = q.enqueue(counter) 

# 把两个操作变成列表中的一个元素
# 原 ：qr = tf.train.QueueRunner(q,enqueue_ops=[increment_op,enqueque_op]*1)
qr = tf.train.QueueRunner(q,enqueue_ops=[[increment_op,enqueque_op]]*1)

sess = tf.Session()
sess.run(tf.global_variables_initializer())

enqueue_threads = qr.create_threads(sess,start=True)

for i in range(10):
    print(sess.run(q.dequeue()))
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0

# 方法2
import tensorflow as tf

q = tf.FIFOQueue(1000,"float")  
counter = tf.Variable(0.0)  
increment_op = tf.assign_add(counter,tf.constant(1.0))  
# 原 enqueque_op = q.enqueue(counter) 

# 把加一操作变成入队操作的依赖
with tf.control_dependencies([increment_op]):
    enqueque_op = q.enqueue(counter)
# 由于将加1变成了入队的依赖，所以入队操作只需要传入enqueque_op就行了
qr = tf.train.QueueRunner(q,enqueue_ops=[enqueque_op]*1)

sess = tf.Session()
sess.run(tf.global_variables_initializer())

enqueue_threads = qr.create_threads(sess,start=True)

for i in range(10):
    print(sess.run(q.dequeue()))
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0

# 方法3
import tensorflow as tf

q = tf.FIFOQueue(1000,"float")  
counter = tf.Variable(0.0)  
increment_op = tf.assign_add(counter,tf.constant(1.0))  
enqueque_op = q.enqueue(counter) 

# 把两个操作变成空操作的依赖
with tf.control_dependencies([increment_op,enqueque_op]):
    void_op = tf.no_op()
# 由于将两个操作变成了空操作的依赖，所以入队操作只需要传入void_op就行了
qr = tf.train.QueueRunner(q,enqueue_ops=[void_op]*1)

sess = tf.Session()
sess.run(tf.global_variables_initializer())

enqueue_threads = qr.create_threads(sess,start=True)

for i in range(10):
    print(sess.run(q.dequeue()))
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0

# 方法4
import tensorflow as tf

q = tf.FIFOQueue(1000,"float")  
counter = tf.Variable(0.0)  
increment_op = tf.assign_add(counter,tf.constant(1.0))  
enqueque_op = q.enqueue(counter) 

# 原 ：qr = tf.train.QueueRunner(q,enqueue_ops=[increment_op,enqueque_op]*1)
# 用tf.group()把两个操作组合起来
qr = tf.train.QueueRunner(q,enqueue_ops=[tf.group(increment_op,enqueque_op)]*1)

sess = tf.Session()
sess.run(tf.global_variables_initializer())

enqueue_threads = qr.create_threads(sess,start=True)

for i in range(10):
    print(sess.run(q.dequeue()))
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0

线程和协调器

QueueRunner 有一个问题就是：入队线程自顾自地执行，在需要的出队操作完成之后，程序
没法结束。这样就要使用 tf.train.Coordinator 来实现线程间的同步，终止其他线程。

import tensorflow as tf

q = tf.FIFOQueue(1000,"float")  
counter = tf.Variable(0.0)  
increment_op = tf.assign_add(counter,tf.constant(1.0))  
enqueque_op = q.enqueue(counter) 

qr = tf.train.QueueRunner(q,enqueue_ops=[[increment_op,enqueque_op]]*1)

# 主线程
sess = tf.Session()
sess.run(tf.global_variables_initializer())

#coordinator:协调器，协调线程间的关系可以被当做一种信号量，起同步作用
coord = tf.train.Coordinator()

# 启动入队线程，协调器是线程的参数
enqueue_threads = qr.create_threads(sess,coord=coord,start=True)

# 主线程
for i in range(0,10):
    print(sess.run(q.dequeue()))

coord.request_stop() # 通知其他线程关闭
 # join操作等待其他线程结束，其他所有的线程关闭后，这个函数才能返回
coord.join(enqueue_threads)  
1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0

异常

for i in range(10):
    print(sess.run(q.dequeue()))
21.0
22.0
23.0
24.0



---------------------------------------------------------------------------

OutOfRangeError                           Traceback (most recent call last)

C:\Anaconda3\envs\tensorflow-gpu\lib\site-packages\tensorflow\python\client\session.py in _do_call(self, fn, *args)
   1326     try:
-> 1327       return fn(*args)
   1328     except errors.OpError as e:


C:\Anaconda3\envs\tensorflow-gpu\lib\site-packages\tensorflow\python\client\session.py in _run_fn(session, feed_dict, fetch_list, target_list, options, run_metadata)
   1305                                    feed_dict, fetch_list, target_list,
-> 1306                                    status, run_metadata)
   1307

在关闭队列线程后，再执行出队操作，就会抛出 tf.errors.OutOfRange 错误。这种情况就需要
使用 tf.errors.OutOfRangeError 来捕捉错误，终止循环：

import tensorflow as tf

q = tf.FIFOQueue(1000,"float")  
counter = tf.Variable(0.0)  
increment_op = tf.assign_add(counter,tf.constant(1.0))  
enqueque_op = q.enqueue(counter) 

qr = tf.train.QueueRunner(q,enqueue_ops=[[increment_op,enqueque_op]]*1)

# 主线程
sess = tf.Session()
sess.run(tf.global_variables_initializer())

#coordinator:协调器，协调线程间的关系可以被当做一种信号量，起同步作用
coord = tf.train.Coordinator()

# 启动入队线程，协调器是线程的参数
enqueue_threads = qr.create_threads(sess,coord=coord,start=True)

coord.request_stop() # 通知其他线程关闭

# 主线程
for i in range(0,10):
    try:
        print("i : ",i)
        print(sess.run(q.dequeue()))
    except tf.errors.OutOfRangeError:
        print('finish')
        break

# join操作等待其他线程结束，其他所有的线程关闭后，这个函数才能返回
coord.join(enqueue_threads)   
i :  0
1.0
i :  1
finish

说明：从打印出来的信息我们可以看出，将请求线程关闭放置在出队的前面，也就是说我还没有出
队之前就请求将线程关闭了，但关闭线程需要一定的时间，所以后来在遍历出队是还是可以执行的
线程关闭后，如果不抛异常的话就像上个例子那样会报错，所以这里执行了异常，并打印出了
“finish”。

参考文献：
http://blog.csdn.net/shenxiaolu1984/article/details/53024513

ggwcr
关注
专栏目录
【TensorFlow】数据处理（队列和多线程）
widiot的博客
12-17 2529
项目已上传至 GitHub —— queue-threading QueueTensorFlow 提供了两种列队 FIFOQueue：先进先出队列 RandomShuffleQueue：随机出队队列 修改队列状态的函数主要有 enqueue()：入队 enqueue_many()：将多个元素入队 dequeue()：出队 以下代码示范了怎么使用这些函数（以下所有代码都实现自《TensorFlow：实
TensorFlow笔记之基础总结
萝卜虫的博客
04-27 1796
本文主要对TensorFlow的基础知识做一下总结回顾计算图：计算模型计算图概念　　TensorFlow的所有计算都会被转化为计算图上的节点。 Tensor就是张量。可以简单理解为多维数组，表明了它的数据结构，Flow就是“流”，它直观地表达了张量之间通过计算相互转化的过程。 　　TensorFlow是一个通过计算图的形式来表述计算的编程系统。TensorFlow的每一个计算都是计算图上的一个节
TensorFlowIO操作（一）----线程和队列
weixin_30340819的博客
10-15 117
线程和队列 在使用TensorFlow进行异步计算时，队列是一种强大的机制。 为了感受一下队列，让我们来看一个简单的例子。我们先创建一个“先入先出”的队列（FIFOQueue），并将其内部所有元素初始化为零。然后，我们构建一个TensorFlow图，它从队列前端取走一个元素，加上1之后，放回队列的后端。慢慢地，队列的元素的值就会增加。 TensorFlow提供了两个类来帮助多线程的...
TensorFlow官方文档线程和队列
HowardWood的博客
02-28 462
线程和队列在使用TensorFlow进行异步计算时，队列是一种强大的机制。艾伯特（http://www.aibbt.com/）国内第一家人工智能门户正如TensorFlow中的其他组件一样，队列就是TensorFlow图中的节点。这是一种有状态的节点，就像变量一样：其他节点可以修改它的内容。具体来说，其他节点可以把新元素插入到队列后端(rear)，也可以把队列前端(front)的元素删除。为了感受...
tensorflow中的队列和线程
修炼之路
08-24 1631
一、队列 tensorflow中主要有FIFOQueue和RandomShuffleQueue两种队列，下面就详细介绍这两种队列的使用方法和应用场景。 1、FIFOQueue FIFOQueue是先进先出队列，主要是针对一些序列样本。如：在使用循环神经网络的时候，需要处理语音、文字、视频等序列信息的时候，我们希望处理的时候能够按照顺序进行，这时候就需要使用FIFOQueue队列。 ...
TensorFlow中队列与线程
The Thinker
10-01 755
1. FIFOQueue : 先入先出的队列 import tensorflow as tf # 在使用循环神经网络时,希望读入的训练样本是有序的可使用FIFOQueue # 先创建一个先入先出的队列,初始化队列插入0.1,0.2,0.3三个数字 q = tf.FIFOQueue(3,tf.float32) init = q.enqueue_many(([0.1,0.2,0.3],)) ...
Python深度学习笔记02——线程队列与tensorflow的io操作(贰)
Liii_NN的博客
08-23 431
前言 一、文件读取 1、文件读取流程 2、文件读取基本知识 1）文件读取API-文件队列构造 2）文件读取API-文件阅读器 3）文件读取API-文件内容解码器 4）开启线程操作 5）管道读端批处理 3、案例实现 二、图片处理 1、图像基本知识 2、图像基本操作API 3、图片读取实例 总结
机器学习Tensorflow基础知识、张量与变量
采菊东篱下，Python满乾坤！
03-25 7102
TensorFlow是一个采用数据流图（data flow graphs），用于数值计算的开源软件库。节点（Nodes）在图中表示数学操作，图中的线（edges）则表示在节点间相互联系的多维数据数组，即张量（tensor）。它灵活的架构让你可以在多种平台上展开计算，例如台式计算机中的一个或多个CPU（或GPU），服务器，移动设备等等。TensorFlow 最初由Google大脑小组（隶属于Goog...
Python基础知识总结笔记（七）常用第三方库
12-22
这使得我们能够灵活地为程序指定配置文件、爬虫文件和线程数量。 2. **Pillow**：这是一个图像处理库，基于Python Imaging Library（PIL）。它可以用于打开、操作和保存各种图像文件格式。在示例中，展示了如何打开...
狂神说笔记（最全）.zip
03-21
数据结构与算法是计算机科学基础，笔记会详细讲解数组、链表、栈、队列、树、图、排序算法和搜索算法等。 人工智能章节可能涵盖机器学习的基本概念、神经网络、深度学习框架（如TensorFlow和PyTorch）、自然语言...
TensorFlow队列与多线程
dz4543的博客
03-21 366
1  tf.Coordinator     TensorFlow提供俩个类tf.Coordinator和tf.QueueRunner来完成多线程协同的功能。tf.Coordinator主要用于协同多个线程一起停止，并提供了should_stop、request_stop和join三个函数。在线程启动之前，需要声明一个tf.Coordinator，并将这个类传入每一个创建的线程中。启动的线程需要一直...
tensorflow之队列，线程，输入
hh_2018的博客
06-12 405
本博客纯属转载 一、队列和线程  1、队列: 　　1)、tf.FIFOQueue(capacity, dtypes, name='fifo_queue') 创建一个以先进先出的顺序对元素进行排队的队列 　　　　参数: 　　　　　　capacity：整数。可能存储在此队列中的元素数量的上限 　　　　　　dtypes：DType对象列表。长度dtypes必须等于每个队列元 素中的张量数,d...
tensorflow多线程
qq_20849045的博客
10-17 2597
本文所有内容均不是原创，仅是看到好的资源，转载到这里，方便自己查找，所有来源都会标注清楚。 https://www.cnblogs.com/demian/p/8005407.html 如果你打开了这篇博客，推荐去上面链接读原文，原文写的更好。 Tf中的队列tensorflow的session对象可以支持多线程，多线程可以方便地使用同一个Session并执行，然而，Python中的并行运算并不...
【踩坑】framework.errors_impl.OutOfRangeError: RandomShuffleQueue '_1_shuffle_batch/random_shuffle_queue
清凌的博客
02-23 1438
解决方案： 1.检查文件路径是否有误： 比如我这里，我之前写错了，弄成了../data/test/ 但是我的代码文件在其他的磁盘，不在数据盘，就造成了这个bug 2.检查一下你的batch_size是不是过大了，磁盘读取打满了但是还是没读取到你的数据目标值： 例如： 这里的batch_size我在其他地方设置，设置得太大了，导致磁盘没读取到多线程程序就处理了。 就会爆出这个问题，你应该根据自己的...
Tensorflow笔记(基础):队列与线程
weixin_30325487的博客
08-04 168
前言 在Tensorflow的实际应用中,队列与线程是必不可少,主要应用于数据的加载等,不同的情况下使用不同的队列,主线程与其他线程异步进行数据的训练与读取,所以队列与线程的知识也是Tensorflow必须要学会的重要知识 另一方面,Tensorflow作为符号编程框架,在构图后,加载数据有三种方式,预加载与填充数据都存在,数据量大消耗内存等情况的出现.使用第三种方式文件读取...
tensorflow 报错: tensorflow.python.framework.errors_impl.NotFoundError
热门推荐
tz_zs的博客
08-02 6万+
____tz_zs报错代码：我是持久化存储，创建文件的代码 tf.gfile.GFile("/path/to/model/combined_model.pb", "wb") 运行报错bug描述:tensorflow.python.framework.errors_impl.NotFoundError: Failed to create a NewWriteableFile: /path/to/mo...
tensorflow.python.framework.errors_impl.InvalidArgumentError:
fu6543210的博客
06-26 2万+
tensorflow.python.framework.errors_impl.InvalidArgumentError: Negative dimension size caused by subtracting 2 from 1 for 'max_pooling2d_2/MaxPool' (op: 'MaxPool') with input shapes: [?,1,128,128].报这种类...
tensorflow.python.framework.errors_impl.InvalidArgumentError
西檬饭
02-11 5303
尝试使用一个for循环训练10次神经网络取10次结果作为均值，for循环第一次能够正常运行，当i =1时，报错： tensorflow.python.framework.errors_impl.InvalidArgumentError: You must feed a value for placeholder tensor ‘Placeholder’ with dtype float [[nod...
tensorflow中线程和队列
summer2day的博客
09-07 277
队列（queue）本身也是图中的一个节点，是一种有状态的节点，主要包括入队节点（enqueue）和出队节点(dequeue)，可以修改它的内容。enqueue操作返回计算图中的一个Operation节点，dequeue操作返回一个Tensor值。Tensor在创建时同样只是一个定义（或称为“声明”），需要放在Session中运行才能获得真正的数值。 FIFOQueue先入先出队列 im...
C语言基础知识学习笔记：从C++入门
这篇学习笔记主要涵盖了C语言的基础知识，适合初学者入门。作者以章节的形式介绍了C语言的关键概念，包括语句的种类、控制结构以及基本的编程元素。 ### 第四章：语句 #### 4.1 空语句 一个分号`;`就构成了一个空...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值