- 贝贝
-
下列属性中TensorFlow2.0不支持创建tensor的方法是?()
A.zeros
B.fill
C.create
D.constant
正确答案:C
TF2 基础 (2) : Tensor 介绍
本文是对 官方文档 的学习笔记。 Tensor 的特点: 这是一个 0 阶 Tensor, 没有“轴” 一阶 Tensor 类似一个 List, 有一个“轴” 二阶 Tensor 类似一个 Matrix , 有两个“轴” 高阶 Tensor, 这是个 3阶 Tensor , shape 是 [3, 2, 5] 注意:shape 的规则,最内部的数据个数, 在最后边。 比如上例, 它的shape 是 [3, 2, 5], 意思是最内部的数组(不再包含其他数组)所包含的元素是 5个, 次内部的数组,每个包含2个元素, 以此类推。 对于一般的 Tensor 来说 tf.Tensor (之前我们讨论的) 要求内部数据形状必须是矩形 (所有轴上的数据长度相等), 但也有比较特殊的Tensor , 支持不规则数据形状。 Tensor 支持常见的数学运算 关于 Tensor 的词汇 关于这一段, 原文里面大部分说的很抽象, 没啥指导意义。 倒是这张图, 还有其中的一句话比较有意义。 右边的数值,更加local ,而且在内存上距离更近。 比如上面图所示, 右边的feature 就表示一个sample 的中的feature ,他们之间距离更近。 TensorFlow index 规则: 把 [3,1] shape 转换成 Python list : as_list reshape 是转换Tensor shape 的最简单的方式 reshape 以后, Tensor 对象会更新, 新的Tensor 还指向相同的数据(The data maintains its layout in memory and a new tensor is created, with the requested shape, pointing to the same data. ) 用: tf.reshape(some_tensor, [-1]) reshape 一般用于增加、减少一个维度。对于上面 3* 2 * 3 Tensor 的例子,减少维度的例子: 如下, 改变轴的顺序应该用 tf.transpose 有人称为是动态形状 Tensor 广播是从NumPy中的等效功能中借用的概念。简而言之,在某些情况下,在对它们进行组合操作时,较小的张量会自动“拉伸”以适合较大的张量。 最简单和最常见的情况是尝试将张量乘或加到标量时。在这种情况下,标量被广播为与其他自变量相同的形状。 在大多数情况下,广播既节省时间又节省空间,因为广播操作永远不会实现内存中扩展的张量。 注意, 这不和上面广播不一样, broadcast_to 产生的新 Tensor 并不会节约内存。 TF2 中很多函数都会要求参数是 Tensor ,如果参数不是 Tensor 则会调用 convert_to_tensor 来做转换。 有些类型, 比如 ndarray, TensorShape,Python list, tf.Variable 已经“注册”了, 他们可以自动转换成 Tensor。 对于自定义类型, 可以 tf.register_tensor_conversion_function 来注册转换函数。 沿某个轴具有可变数量元素的张量称为“Ragged Tensors”。使用 tf.ragged.RaggedTensor处理不整齐的数据。 例如 普通 Tensor 处理不了长短不一的情况 tf.string是dtype,也就是说您可以将数据表示为张量中的字符串(可变长度字节数组)。 这些字符串是原子的,无法像Python字符串那样被索引。字符串的长度不是张量的轴之一。有关操作它们的功能,请参见 tf.strings 。 在上面的打印输出中,b前缀表示tf.string dtype不是unicode字符串,而是字节字符串。有关在TensorFlow中处理Unicode文本的更多信息,请参见Unicode教程。 如果传递unicode字符,则它们是utf-8编码的。 可以在tf.strings中找到一些带有字符串的基本功能,包括tf.strings.split。 其他更多关于 String Tensor ,可以参考 string_tensors Sparse tensors 用来存储稀疏矩阵类型的数据。2023-08-03 04:58:131
什么是张量 (tensor)?
张量(tensor)理论是数学的一个分支学科,在力学中有重要应用。张量这一术语起源于力学,它最初是用来表示弹性介质中各点应力状态的,后来张量理论发展成为力学和物理学的一个有力的数学工具。张量之所以重要,在于它可以满足一切物理定律必须与坐标系的选择无关的特性。张量概念是矢量概念的推广,矢量是一阶张量。张量是一个可用来表示在一些矢量、标量和其他张量之间的线性关系的多线性函数。张量的理论来源。亚瑟·凯莱(Arthur Cayley)着力研究的不变量理论(invariant theory)导致了矩阵理论的建立,引进了现代意义上的行列式的代数表达,这成为射影几何的重要工具。凯莱的不变量理论产生于19世纪前半叶的英国着重对代数及代数在几何方面的应用研究这样的背景下。矩阵理论对线性变换的研究引进了向量的代数定义,而这是张量概念的先导。2023-08-03 04:58:201
MNN源码阅读--Tensor数据结构解析和运行示例
tensor就是容纳推理框架中间数据的一个数据结构,常用的有关函数如下: 这其中第一个参数是tensor的维度信息,第二个参数是是否指定数据指针,第三个参数是数据在内存中的排布信息,如果是CAFFE证明是NCHW类型,如果是TENSORFLOW证明是NHWC类型,默认的类型是TENSORFLOW类型,这里经常会有一些坑,比如最终想要得到一个1 3 1024*1024的数据时候,如果没有指定是CAFFE类型的数据排布,而是使用默认的情况(TENSORFLOW),读出来的数据channel维度就在最后。 得到各种维度和长度: 得到shape向量和数据总数: 得到数据指针: Interpreter就是一个MNN的从模型得到的一个网络,有关Interpreter的tenosr操作,肯定就是涉及到输入的tesnor和输出的tensor的设置,由于可能在不同的设备上运行,因此可能有内存拷贝的操作。 获取Interpreter的输入tensor: 获取Interpreter的输出tensor: 将host的tensor数据拷贝给Interpreter的tensor 将Interpreter的tensor数据拷贝给host tensor2023-08-03 04:58:341
Pytorch中的tensor常用操作
在指定的维度dim上对序列seq进行连接操作。 参数: 例子: torch.Tensor.expand( sizes)* → Tensor 返回张量的一个新视图,可以将张量的单个维度扩大为更大的尺寸。 张量也可以扩大为更高维,新增加的维度将附在前面。 扩大张量不需要分配新内存,仅仅是新建一个张量的视图。任意一个一维张量在不分配新内存情况下都可以扩展为任意的维度。 传入-1则意味着维度扩大不涉及这个维度。 参数: 例子: torch.squeeze(input, dim=None, out=None) → Tensor 除去输入张量input中数值为1的维度,并返回新的张量。如果输入张量的形状为( [图片上传失败...(image-786ec5-1580566115084)] ),那么输出张量的形状为( [图片上传失败...(image-a0a179-1580566115084)] )。 当通过dim参数指定维度时,维度压缩操作只会在指定的维度上进行。如果输入向量的形状为( [图片上传失败...(image-1088a1-1580566115084)] ),squeeze(input, 0)会保持张量的维度不变,只有在执行squeeze(input, 1)时,输入张量的形状会被压缩至( [图片上传失败...(image-759892-1580566115084)] )。 如果一个张量只有1个维度,那么它不会受到上述方法的影响。 输出的张量与原张量共享内存,如果改变其中的一个,另一个也会改变。 参数: 例子: torch.Tensor.repeat( sizes)* 沿着指定的维度重复张量。不同于expand()方法,本函数复制的是张量中的数据。 参数: 例子: torch.Tensor.unfold(dim, size, step) → Tensor 返回一个新的张量,其中元素复制于有原张量在dim维度上的数据,复制重复size次,复制时的步进值为step。 参数: 例子: torch.Tensor.narrow(dimension, start, length) → Tensor 返回一个经过缩小后的张量。操作的维度由dimension指定。缩小范围是从start开始到start+length。执行本方法的张量与返回的张量共享相同的底层内存。 参数: 例子: torch.Tensor.view( args)* → Tensor 返回一个有相同数据但是不同形状的新的向量。 返回的装两必须与原张量有相同的数据和相同的元素个数,但是可以有不同的尺寸。 参数: 例子: torch.Tensor.resize_( sizes)* 将张量的尺寸调整为指定的大小。如果元素个数比当前的内存大小大,就将底层存储大小调整为与新元素数目一致的大小。 如果元素个数比当前内存小,则底层存储不会被改变。原来张量中被保存下来的元素将保持不变,但新内存将不会被初始化。 参数: 例子: torch.Tensor.permute( dims)* 将执行本方法的张量的维度换位。 参数: 例子: torch.Tensor.element_size() → int 查看某类型张量单个元素的字节数。 例子:2023-08-03 04:58:421
通俗理解张量tensor
我们的目的是要用数学量来表示物理量,可是标量加上向量,都不足以表达所有的物理量,所以就需要扩大数学量的概念,张量就出现了。 几何代数中定义的张量是基于向量和矩阵的推广,通俗一点理解的话,我们可以将标量视为零阶张量,矢量视为一阶张量,那么矩阵就是二阶张量。 张量的严格定义是利用线性映射来描述的。与矢量相类似,定义由若干坐标系改变时满足一定坐标转化关系的有序数组成的集合为张量。 从几何角度讲, 它是一个真正的几何量,也就是说,它是一个不随参照系的坐标变换(其实就是基向量变化)而变化的东西。最后结果就是基向量与对应基向量上的分量的组合(也就是张量)保持不变,比如一阶张量(向量) a 可表示为 a = x* i + y* j 。由于基向量可以有丰富的组合,张量可以表示非常丰富的物理量。 换一种定义方式 一个(p,q)型张量,就是一个映射: 啰嗦一下 如果一个物理量,在物体的某个位置上只是一个单值,那么就是普通的标量,比如密度。如果它在同一个位置、从不同的方向上看,有不同的值,而且这个数恰好可以用矩阵乘观察方向来算出来,就是张量。 张量积这种东西有很多种理解方式,在不同的语境下面会有不同的看法。但是如果拿来跟矩阵乘积比较的话,我觉得比较好的说法是,张量积是一种万有乘积,而矩阵乘法是一种具体化。 我们现在手里有很多矩阵,然后希望把两个矩阵乘起来。一开始肯定想不到怎么乘,但是可以猜一些乘积的最基本的性质,比如说要和数乘是匹配的,也要和加法匹配也就是分配律。不管这个乘积是什么,都应当有这些基本的性质。那么这个时候张量积就出现了,他代表了最广的乘积,也是最弱的乘积,就仅仅满足上面说的那些基本性质。正因为是最弱的,所以一切具体的乘积都可以看成是从张量积的结果具体化得到的,也就是可以看成是万有乘积,或者是一个包络的乘积。 在 数学 中, 张量积 ,记为 向量可以表示什么? 比如,我们可以用一个平面的法向量代表这个平面;物理上可以用向量代表力等。看来,向量可以表示很多东西,不过仔细想想向量也只表示了幅度(magnitude)与方向(direction)两个要素而已。 一个向量有很多种表示方式,我们可以用[0, 1]表示一个二维向量,也可以用平面、三维或更高维空间中的一条带箭头的线表示一个向量。我们都是知道(0, 0) —> (1, 1)可表示一个从(0, 0)到(1, 1)的有向线段(向量),那么,为什么可以用[0, 1]表示一个向量呢? 根据前面的讲解,我们知道一个向量就是空间中的一条有向线段,可以用一组坐标系的基和向量相应分量的乘积组合来表示。由于坐标系有很多种定义方式,基也就有很多种,对应的分量也会有很多种,但如果大家默认使用同一套基向量,那么基向量都不需要了,此时,想要表示一个向量,只要给定这三个分量即可,比如用0, 1表示一个向量,如果加上两个括号,这就是我们在书上经常看到的向量的列表示(0, 1),三维的有(1, 2, 1)。贴一个很有爱的图2023-08-03 04:58:551
tensor g2相当于骁龙
tensorg2芯片相当于骁龙888处理器。GoogleTensor芯片相当于骁龙888处理器,GoogleTensorG2芯片单核成绩是1068,多核成绩是3149,而骁龙888处理器Geekbench单核成绩在1100分左右。谷歌TensorG2处理器由两颗CortexX1超大核、两颗CortexA76大核和四颗CortexA55小核组成,基于三星4nm工艺制程打造,CPU性能仅仅提升了10%左右。GoogleTensorG2超大核CortexX1主频仅提升50MHz,达到2、85GHz,CortexA76大核提升100MHz,达到2、35GHz,其对手高通骁龙8+CPU超大核主频达到了3、2GHz。谷歌自研Tensor处理器芯片由GooglePixel7Pro首发搭载,从GoogleTensorG2跑分来看,在今年安卓旗舰阵营中,谷歌Pixel7Pro性能属于垫底级别,相比上代没有太大提升。骁龙芯片特征:骁龙是QualcommTechnologies(美国高通)旗下移动处理器和LTE调制解调器的品牌名称。骁龙处理器具备高速的处理能力,可提供令人惊叹的逼真画面以及超长续航时间。随着产品系列不断丰富,可带来目前最先进的移动体验。2013年1月,QualcommTechnologies宣布为骁龙处理器引入全新命名方式和层级,包含骁龙800系列、骁龙600系列、骁龙400系列和骁龙200系列处理器。骁龙处理器是高度集成的移动优化系统级芯片(SoC),它结合了业内领先的3G/4G移动宽带技术与强大的多媒体功能、3D图形功能和GPS引擎,可为移动终端带来极高的处理速度、极低的功耗、逼真的多媒体和全面的连接性。以上内容参考:百度百科-骁龙2023-08-03 04:59:021
Pytorch | tensor 切分方法
数据的预处理以及数据集的构建会经常使用到tensor的切分操作,现整理如下: 功能 :输入数据与想要切分的块数 chunks ,将数据尽可能 (如果数据个数与块数能整除的话) 平均的切分为 chunks 块 注意 :没有进行数据的拷贝 参数 Test Output 功能 : 注意 :没有对输入数据进行拷贝 参数 : Test 1 输入整型数据 Output 1 Test 2 输入为整型序列 Output 功能 :torch支持numpy中对数据的切片操作 Test Output 功能 :删除tensor的一个维度,返回各个子块组成的 tuple 参数 : Test Output 感谢你的阅读,如果文中存在错误,还请在评论区指出~2023-08-03 04:59:171
服务器系列(23):tensor、numpy.array、list三者之间互相转换
ValueError:only one element tensors can be converted to Python scalars问题解答 1.1 list 转 numpy ndarray = np.array(list) 1.2 numpy 转 list list = ndarray.tolist() 2.1 list 转 torch.Tensor tensor=torch.Tensor(list) 2.2 torch.Tensor 转 list 先转numpy,后转list list = tensor.numpy().tolist() 3.1 torch.Tensor 转 numpy ndarray = tensor.numpy() *gpu上的tensor不能直接转为numpy ndarray = tensor.cpu().numpy() 3.2 numpy 转 torch.Tensor tensor = torch.from_numpy(ndarray)2023-08-03 04:59:241
python如何判断tensor是否存在某个元素
可以利用in运算符来进行判断。如果在指定的序列中找到值返回True,否则返回False。运算符notin表示如果在指定的序列中没有找到值返回True,否则返回False。Python字典in操作符用于判断键是否存在于字典中,如果键在字典dict里返回true,否则返回false。此方法用于列表可以判断元素是否在列表中。2023-08-03 04:59:421
TensorFlow2 基础知识: Tensor, Shape, Rank
Tensor 是 TensorFlow 中基础的计算单元,它包括以下四个主要组成部分: 当不知道某个维度的大小时, 可以用 None 代替, 表示 Unknown 实际使可能遇到的几种Shape 的情况 因为TensorFlow 是先定义, 后执行, 有些信息在运行 Computation Graph 的时候再运算, 所以会出现上述在定义时, 未知的情况。 参考文档: [1] Understanding Tensorflow"s tensors shape: static and dynamic, Paolo Galeone, 01/28/20182023-08-03 04:59:501
tensor.view()、tensor.reshape()、tensor.resize_() 三者的区别
我们已经知道pytorch的tensor由“头信息区”和“storage”两部分组成,其中tensor的实际数据是以一维数组(storage)的方式存于某个连续的内存中的。。 view 从字面意思上就是“ 视图 ”的意思,就是将原tensor以某种排列方式展示给我们, view()不会改变原storage、也不会新建storage,只新建头信息区 。 本质上, view()返回的是针对一维storage的某种排列视图,并且这种视图只能是连续、等距切分storage再连续竖向叠加形成的视图,不能跳跃式切分 ,如下图例子。 注意:如果tensor是不连续的,则不能使用view()( https://www.jianshu.com/p/51678ea7a959 )。 我们知道,tensor不连续是不能使用 view() 方法的。 只有将不连续tensor转化为连续tensor(利用contiguous(), https://www.jianshu.com/p/51678ea7a959 )后,才能使用view()。 reshape()正是先完成连续化,然后再进行view() 。 reshape() 和 view() 的区别: (1)当 tensor 满足连续性要求时,reshape() = view(),和原来 tensor 共用存储区; (2)当 tensor不满足连续性要求时,reshape() = **contiguous() + view(),会产生有新存储区的 tensor,与原来tensor 不共用存储区。 前面说到的 view()和reshape()都必须要用到全部的原始数据,比如你的原始数据只有12个,无论你怎么变形都必须要用到12个数字,不能多不能少。因此你就不能把只有12个数字的 tensor 强行 reshap 成 2×5 的。 但是 resize_() 可以做到,无论原始存储区有多少个数字,我都能变成你想要的维度,数字不够怎么办?随机产生凑!数字多了怎么办?就取我需要的部分! 1.截取时: 会改变原tensor a,但不会改变storage(地址和值都不变),且a和b共用storage(这里是2638930351680 )。 2.添加时:会改变原tensor a,且会改变storage(地址和值都变),但a和b还是共用storage(这里是2638924338752 )。2023-08-03 04:59:571
tensorflow打印tensor的值
调试程序时候,有时候需要打印tensor的值的时候,直接print显示的是如下tensor的shape、dtype等信息 使用如下方法可打印tensor值 结果:2023-08-03 05:00:041
对tensor变量切片等操作怎么进行
可以直接取tensor变量的一部分,但是不能给tensor变量赋值>>> import numpy as np>>> import theano>>> from theano.tensor.basic import as_tensor_variable>>> b=np.random.rand(4,2)>>> m=as_tensor_variable(b)>>> m[0][0]Subtensor{int64}.0>>> n=m[0][0] #取m的第一个值,n是Subtensor>>> nSubtensor{int64}.0>>> n.eval()array(0.3710058805503049)>>> m.eval()array([[ 0.37100588, 0.95565751],[ 0.86516759, 0.94976681],[ 0.09564244, 0.65019287],[ 0.59892358, 0.4180284 ]])>>> type(m)<class "theano.tensor.var.TensorConstant">>>> m[0][0]=0Traceback (most recent call last):File "<stdin>", line 1, in <module>TypeError: "TensorVariable" object does not support item assignment>>> m[0][0].eval()=0File "<stdin>", line 1SyntaxError: can"t assign to function call>>> n =m[1:3] #取m的第23行>>> n.eval()array([[ 0.86516759, 0.94976681],[ 0.09564244, 0.65019287]])2023-08-03 05:00:121
with torch.no_grad()
在讲述with torch.no_grad()前,先从requires_grad讲起 在pytorch中,tensor有一个requires_grad参数,如果设置为True,则反向传播时,该tensor就会自动求导。tensor的requires_grad的属性默认为False,若一个节点(叶子变量:自己创建的tensor)requires_grad被设置为True,那么所有依赖它的节点requires_grad都为True(即使其他相依赖的tensor的requires_grad = False) 首先说明,该用法已经被移除,但为了说明torch.no_grad,还是需要讲解下该作用。在之前的版本中,tensor(或者说variable,以前版本tensor会转化成variable,目前该功能也被废弃,直接使用tensor即可)还有一个参数volatile,如果一个tensor的volatile = True,那么所有依赖他的tensor会全部变成True,反向传播时就不会自动求导了,因此大大节约了显存或者说内存。 既然一个tensor既有requires_grad,又有volatile,那么当两个参数设置相矛盾时怎么办?volatile=True的优先级高于requires_grad,即当volatile = True时,无论requires_grad是Ture还是False,反向传播时都不会自动求导。volatile可以实现一定速度的提升,并节省一半的显存,因为其不需要保存梯度。(volatile默认为False,这时反向传播是否自动求导,取决于requires_grad) with torch.no_grad 上文提到volatile已经被废弃,替代其功能的就是with torch.no_grad。作用与volatile相似,即使一个tensor(命名为x)的requires_grad = True,由x得到的新tensor(命名为w-标量)requires_grad也为False,且grad_fn也为None,即不会对w求导。例子如下所示: 引用: https://blog.csdn.net/weixin_43178406/article/details/895170082023-08-03 05:00:191
tensorflow中一个tensor怎么转化成tf.get_variable格式
基本使用使用 TensorFlow, 你必须明白 TensorFlow:使用图 (graph) 来表示计算任务.在被称之为 会话 (Session) 的上下文 (context) 中执行图.使用 tensor 表示数据.通过 变量 (Variable) 维护状态.使用 feed 和 fetch 可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据.综述TensorFlow 是一个编程系统, 使用图来表示计算任务. 图中的节点被称之为 op(operation 的缩写). 一个 op 获得 0 个或多个 Tensor, 执行计算,产生 0 个或多个 Tensor. 每个 Tensor 是一个类型化的多维数组.例如, 你可以将一小组图像集表示为一个四维浮点数数组,这四个维度分别是 [batch, height, width, channels].一个 TensorFlow 图描述了计算的过程. 为了进行计算, 图必须在 会话 里被启动.会话 将图的 op 分发到诸如 CPU 或 GPU 之类的 设备 上, 同时提供执行 op 的方法.这些方法执行后, 将产生的 tensor 返回. 在 Python 语言中, 返回的 tensor 是numpy ndarray 对象; 在 C 和 C++ 语言中, 返回的 tensor 是tensorflow::Tensor 实例.计算图TensorFlow 程序通常被组织成一个构建阶段和一个执行阶段. 在构建阶段, op 的执行步骤被描述成一个图. 在执行阶段, 使用会话执行执行图中的 op.例如, 通常在构建阶段创建一个图来表示和训练神经网络, 然后在执行阶段反复执行图中的训练 op.TensorFlow 支持 C, C++, Python 编程语言. 目前, TensorFlow 的 Python 库更加易用,它提供了大量的辅助函数来简化构建图的工作, 这些函数尚未被 C 和 C++ 库支持.三种语言的会话库 (session libraries) 是一致的.构建图构建图的第一步, 是创建源 op (source op). 源 op 不需要任何输入, 例如 常量 (Constant). 源 op 的输出被传递给其它 op 做运算.Python 库中, op 构造器的返回值代表被构造出的 op 的输出, 这些返回值可以传递给其它op 构造器作为输入.TensorFlow Python 库有一个默认图 (default graph), op 构造器可以为其增加节点. 这个默认图对许多程序来说已经足够用了. 阅读 Graph 类 文档来了解如何管理多个图.import tensorflow as tf# 创建一个常量 op, 产生一个 1x2 矩阵. 这个 op 被作为一个节点# 加到默认图中.## 构造器的返回值代表该常量 op 的返回值.matrix1 = tf.constant([[3., 3.]])# 创建另外一个常量 op, 产生一个 2x1 矩阵.matrix2 = tf.constant([[2.],[2.]])# 创建一个矩阵乘法 matmul op , 把 "matrix1" 和 "matrix2" 作为输入.# 返回值 "product" 代表矩阵乘法的结果.product = tf.matmul(matrix1, matrix2)默认图现在有三个节点, 两个 constant() op, 和一个matmul() op. 为了真正进行矩阵相乘运算, 并得到矩阵乘法的结果, 你必须在会话里启动这个图.在一个会话中启动图构造阶段完成后, 才能启动图. 启动图的第一步是创建一个 Session 对象, 如果无任何创建参数,会话构造器将启动默认图.欲了解完整的会话 API, 请阅读Session 类.# 启动默认图.sess = tf.Session()# 调用 sess 的 "run()" 方法来执行矩阵乘法 op, 传入 "product" 作为该方法的参数. # 上面提到, "product" 代表了矩阵乘法 op 的输出, 传入它是向方法表明, 我们希望取回# 矩阵乘法 op 的输出.## 整个执行过程是自动化的, 会话负责传递 op 所需的全部输入. op 通常是并发执行的.# # 函数调用 "run(product)" 触发了图中三个 op (两个常量 op 和一个矩阵乘法 op) 的执行.## 返回值 "result" 是一个 numpy `ndarray` 对象.result = sess.run(product)print result# ==> [[ 12.]]# 任务完成, 关闭会话.sess.close()Session 对象在使用完后需要关闭以释放资源. 除了显式调用 close 外, 也可以使用 "with" 代码块来自动完成关闭动作.with tf.Session() as sess: result = sess.run([product]) print result在实现上, TensorFlow 将图形定义转换成分布式执行的操作, 以充分利用可用的计算资源(如 CPU或 GPU). 一般你不需要显式指定使用 CPU 还是 GPU, TensorFlow 能自动检测. 如果检测到 GPU, TensorFlow会尽可能地利用找到的第一个 GPU 来执行操作.如果机器上有超过一个可用的 GPU, 除第一个外的其它 GPU 默认是不参与计算的. 为了让 TensorFlow使用这些 GPU, 你必须将 op 明确指派给它们执行. with...Device 语句用来指派特定的 CPU 或 GPU执行操作:with tf.Session() as sess: with tf.device("/gpu:1"): matrix1 = tf.constant([[3., 3.]]) matrix2 = tf.constant([[2.],[2.]]) product = tf.matmul(matrix1, matrix2) ...设备用字符串进行标识. 目前支持的设备包括:"/cpu:0": 机器的 CPU."/gpu:0": 机器的第一个 GPU, 如果有的话."/gpu:1": 机器的第二个 GPU, 以此类推.阅读使用GPU章节, 了解 TensorFlow GPU 使用的更多信息.交互式使用文档中的 Python 示例使用一个会话 Session 来启动图, 并调用 Session.run() 方法执行操作.为了便于使用诸如 IPython 之类的 Python 交互环境, 可以使用InteractiveSession 代替Session 类, 使用 Tensor.eval()和 Operation.run() 方法代替Session.run(). 这样可以避免使用一个变量来持有会话.# 进入一个交互式 TensorFlow 会话.import tensorflow as tfsess = tf.InteractiveSession()x = tf.Variable([1.0, 2.0])a = tf.constant([3.0, 3.0])# 使用初始化器 initializer op 的 run() 方法初始化 "x" x.initializer.run()# 增加一个减法 sub op, 从 "x" 减去 "a". 运行减法 op, 输出结果 sub = tf.sub(x, a)print sub.eval()# ==> [-2. -1.]TensorTensorFlow 程序使用 tensor 数据结构来代表所有的数据, 计算图中, 操作间传递的数据都是 tensor.你可以把 TensorFlow tensor 看作是一个 n 维的数组或列表. 一个 tensor 包含一个静态类型 rank, 和一个 shape. 想了解 TensorFlow 是如何处理这些概念的, 参见Rank, Shape, 和 Type.变量Variables for more details.变量维护图执行过程中的状态信息. 下面的例子演示了如何使用变量实现一个简单的计数器. 参见变量 章节了解更多细节.# 创建一个变量, 初始化为标量 0.state = tf.Variable(0, name="counter")# 创建一个 op, 其作用是使 state 增加 1one = tf.constant(1)new_value = tf.add(state, one)update = tf.assign(state, new_value)# 启动图后, 变量必须先经过`初始化` (init) op 初始化,# 首先必须增加一个`初始化` op 到图中.init_op = tf.initialize_all_variables()# 启动图, 运行 opwith tf.Session() as sess: # 运行 "init" op sess.run(init_op) # 打印 "state" 的初始值 print sess.run(state) # 运行 op, 更新 "state", 并打印 "state" for _ in range(3): sess.run(update) print sess.run(state)# 输出:# 0# 1# 2# 3代码中 assign() 操作是图所描绘的表达式的一部分, 正如 add() 操作一样. 所以在调用 run()执行表达式之前, 它并不会真正执行赋值操作.通常会将一个统计模型中的参数表示为一组变量. 例如, 你可以将一个神经网络的权重作为某个变量存储在一个 tensor 中.在训练过程中, 通过重复运行训练图, 更新这个 tensor.Fetch为了取回操作的输出内容, 可以在使用 Session 对象的 run() 调用 执行图时, 传入一些 tensor,这些 tensor 会帮助你取回结果. 在之前的例子里, 我们只取回了单个节点 state, 但是你也可以取回多个tensor:input1 = tf.constant(3.0)input2 = tf.constant(2.0)input3 = tf.constant(5.0)intermed = tf.add(input2, input3)mul = tf.mul(input1, intermed)with tf.Session() as sess: result = sess.run([mul, intermed]) print result# 输出:# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]需要获取的多个 tensor 值,在 op 的一次运行中一起获得(而不是逐个去获取 tensor)。Feed上述示例在计算图中引入了 tensor, 以常量或变量的形式存储. TensorFlow 还提供了 feed 机制, 该机制可以临时替代图中的任意操作中的 tensor 可以对图中任何操作提交补丁, 直接插入一个 tensor.feed 使用一个 tensor 值临时替换一个操作的输出结果. 你可以提供 feed 数据作为 run() 调用的参数.feed 只在调用它的方法内有效, 方法结束, feed 就会消失. 最常见的用例是将某些特殊的操作指定为 "feed" 操作,标记的方法是使用 tf.placeholder() 为这些操作创建占位符.input1 = tf.placeholder(tf.float32)input2 = tf.placeholder(tf.float32)output = tf.mul(input1, input2)with tf.Session() as sess: print sess.run([output], feed_dict={input1:[7.], input2:[2.]})# 输出:# [array([ 14.], dtype=float32)]for a larger-scale example of feeds.如果没有正确提供 feed, placeholder() 操作将会产生错误.MNIST 全连通 feed 教程(source code)给出了一个更大规模的使用 feed 的例子.2023-08-03 05:00:292
全新Tensor G2芯片加持,谷歌Pixel 7 Pro有何亮点?
谷歌手机的影像系统一直都是一大卖点,这次谷歌Pixel 7 Pro还可能搭载了一颗潜望式长焦镜头,其拍照能力或许值得我们期待。核心SoC上,2023-08-03 05:00:374
Tensor滑板桥的问题,用过的回答。
知道thunder不错2023-08-03 05:01:053
如何获取tensor某一维度的长度
>>> arr[[10, 11, 12, 13, 14, 15, 16, 17, 18, 19],[11, 12, 13, 14, 15, 16, 17, 18, 19, 20],[12, 13, 14, 15, 16, 17, 18, 19, 20, 21],[13, 14, 15, 16, 17, 18, 19, 20, 21, 22],[14, 15, 16, 17, 18, 19, 20, 21, 22, 23],[15, 16, 17, 18, 19, 20, 21, 22, 23, 24],[16, 17, 18, 19, 20, 21, 22, 23, 24, 25],[17, 18, 19, 20, 21, 22, 23, 24, 25, 26],[18, 19, 20, 21, 22, 23, 24, 25, 26, 27],[19, 20, 21, 22, 23, 24, 25, 26, 27, 28],[20, 21, 22, 23, 24, 25, 26, 27, 28, 29],[21, 22, 23, 24, 25, 26, 27, 28, 29, 30]]>>> l = [x[0] for x in arr]>>> l[10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21]>>>2023-08-03 05:01:141
TensorFlow vs PyTorch 4: 自动微分
使用反向传播法训练神经网络时,模型的参数依据损失函数与对应参数的梯度来调整,即: 自动微分 是机器学习工具包必备的工具,它可以自动计算整个计算图的微分。 PyTorch 内建了一个叫做 torch.autograd 的自动微分引擎,该引擎支持的数据类型为:浮点数Tensor类型 ( half, float, double and bfloat16) 和复数Tensor 类型(cfloat, cdouble) PyTorch 中与自动微分相关的常用的Tensor属性和函数: TensorFlow 通过 tf.GradientTape API来自动追踪和计算微分,GradientTape,翻译为微分带,Tape有点儿历史上磁带机的味道,即在Tape上记录下所有的计算和计算结果。 tf.GradientTape 在tf.Variable而非tf.Tensor上计算,因为在TensorFlow中,tf.Tensor为不可变对象,tf.Variable为可变对象;通常 用tf.Variable来存储模型参数 。 tf.Variable 有一个trainable属性,该属性tf.Tensor没有,类似PyTorch Tensor的requires_grad, 即告知自动微分引擎是否追踪该tf.Variable,并自动计算该tf.Variable的微分。 范例: 从上述可以看到,TensorFlow的自动微分实现方式与PyTorch大不相同,而且 没有把参数和参数的微信封装成一个对象,这点非常不User-Friendly,或者说封装的不好 ! 为了方便实现模型,模型的参数,与模型参数的微分,TensorFlow又提供了另外一套机制: 模型的微分(Gradients with respect to a model) , 意思是:TensorFlow开发团队也知道了用tf.Variable实现模型参数,然后用tape.gradient()方法计算微分,tf.Variable和它对应的微分是分离的,是没有封装好的,这种方式对开发者不友好,所以,TensorFlow开发者团队对于构建模型的基础类: tf.Module 或者它的子类 ( layers.Layer , keras.Model ),提供了一个 Module.trainable_variables 的属性,该属性把模型参数都封装好了,使用起来比较方便。不过对应微分还是没封装,坚持自己的个性...对于我们开发者,还是选择遵循... 范例: 参考资料:2023-08-03 05:01:331
Tensorflow 如何判断两个tensor相等?
进口的当然OK啦2023-08-03 05:01:423
什么叫应力张量
张量 (Tensor) 是 n 维空间内,有 nr个分量的一种量, 其中每个分量都是座标的函数, 而在座标变换时,这些分量也依照某些规则作线性变换。 r 称为该张量的阶 (Rank)。 第零阶张量 (r = 0) 为纯量 (Scalar),第一阶张量 (r = 1) 为向量 (Vector), 第二阶张量 (r = 2) 则成为矩阵 (Matrix)。 例如,对于3维空间,r=1时的张量为此向量:(x,y,x)T。由於变换方式的不同,张量分成协变张量 (Covariant Tensor,志标在下者)、反变张量 (Contravariant Tensor,志标在上者)、 混合张量 (志标在上者和志标在下者都有者) 三类。 在数学里,张量是一种几何实体,或者说广义上的「数量」。张量概念包括标量、矢量和线性算子。张量可以用坐标系统来表达,记作标量的数组,但它是定义为「不依赖于参照系的选择的」。张量在物理和工程学中很重要。例如在扩散张量成像中,表达器官对于水的在各个方向的微分透性的张量可以用来产生大脑的扫描图。可能最重要的工程上的例子就是应力张量和应变张量了,它们都是二阶张量,对于一般线性材料他们之间的关系由一个四阶弹性张量来决定。 虽然张量可以用分量的多维数组来表示,张量理论存在的意义在于进一步说明把一个数量称为张量的涵义,而不仅仅是说它需要一定数量的有指标索引的分量。特别是,在座标转换时,张量的分量值遵守一定的变换法则。张量的抽象理论是线性代数分支,现在叫做多线性代数。2023-08-03 05:01:532
如何将tensor的内容输出到文本文件
local part2 = self.convModel:forward({linputs, rinputs})local length = part2:size(1)local file = io.open("/home/xbwang/Desktop/part2original","a")for j = 1,length donumber = part2[j]file:write(tostring(number).." ")end2023-08-03 05:02:051
下了一个tensor toolbox软件包,为什么在MATLAB中不能用
原因之一是因为没有把tensortoolbox的路径加到matlab工具包下将tensor包拷贝到matlab的安装文件下的toolbox文件目录下,然后在matlab中运行addpathD:/MATLAB/toolbox/tensortoolbox(中间的目录依个人而定),然后运行help‘tensor",若成功则安装成功2023-08-03 05:02:121
tensor,dtype=float32是什么意思
为 会话 (Session) 的上下文 (context) 中执行图. 使用 tensor 表示数据. 通过 变量 (Variable) 维护状2023-08-03 05:02:271
tf.gather和tf.gather_nd的详细用法--tensorflow通过索引取tensor里的数据
在numpy里取矩阵数据非常方便,比如: 这样就把矩阵a中的1,3,5行取出来了。 如果是只取某一维中单个索引的数据可以直接写成 tensor[:, 2] , 但如果要提取的索引不连续的话,在tensorflow里面的用法就要用到tf.gather. tf.gather_nd允许在多维上进行索引: matrix中直接通过坐标取数(索引维度与tensor维度相同): 取第二行和第一行: 3维tensor的结果: 另外还有tf.batch_gather的用法如下: tf.batch_gather(params, indices, name=None) Gather slices from params according to indices with leading batch dims. This operation assumes that the leading dimensions of indices are dense, and the gathers on the axis corresponding to the last dimension of indices . Therefore params should be a Tensor of shape [A1, ..., AN, B1, ..., BM], indices should be a Tensor of shape [A1, ..., AN-1, C] and result will be a Tensor of size [A1, ..., AN-1, C, B1, ..., BM] . 如果索引是一维的tensor,结果和 tf.gather 是一样的.2023-08-03 05:02:341
张量的cp分解和tucker分解的区别在哪
cp分解是把一个tensor分解成若干个秩一张量的和,如图tucker分解有个core tensortucker分解有个core tensor,你可以把它类比成pca中的主成分因子,它可以体现原tensor的大部分性质。然而cp分解并没有。如果Tucker 中的core tensor 是对角的,且I=J=K,则Tucker 退化成CP,也就是说CP是Tucker的一种特殊情况。tensor分解是n-秩与低秩近似,而cp分解是秩与低秩近似$n$-秩又称为多线性秩。一个N阶张量$mathcal{X}$的n-mode秩定义为: egin{equation} rank_{n}(mathcal{X})=rank(X_{(n)}) end{equation} 令$rank_{n}(mathcal{X})=R_{n},n=1,cdots ,N$则$mathcal{X}$叫做秩$(R_1,R_2,cdots,R_n)$的张量。$R_n$可以看作是张量$mathcal{X}$在各个mode上fiber所构成的空间的维度。Tucker分解的唯一性不能保证对于固定的$n$-秩,Tucker分解的唯一性不能保证,一般加上一些约束,如分解得到的因子单位正交约束等。CP分解的求解首先要确定分解的秩1张量的个数,通常我们通过迭代的方法对$R$从1开始遍历直到找到一个合适的解。可加约束的共性在一些应用中,为了使得CP分解更加的鲁棒和精确,可以在分解出的因子上加上一些先验知识即约束。比如说平滑约束(smooth)、正交约束、非负约束(nonegative) 、稀疏约束(sparsity)等。除了可以在Tucker分解的各个因子矩阵上加上正交约束以外,还可以加一些其它约束,比如稀疏约束,平滑约束,非负约束等。另外在一些应用的场景中不同的mode的物理意义不同,可以加上不同的约束。应用领域不同Tucker分解可以看作是一个PCA的多线性版本,因此可以用于数据降维,特征提取,张量子空间学习等。比如说一个低秩的张量近似可以做一些去噪的操作等。Tucker分解同时在高光谱图像中也有所应用,如用低秩Tucker分解做高光谱图像的去噪,用张量子空间做高光谱图像的特征选择,用Tucker分解做数据的压缩等。CP分解已经在信号处理,视频处理,语音处理,计算机视觉、机器学习等领域得到了广泛的应用。2023-08-03 05:02:421
mindspore的tensor与numpy数据类型转换问题?
类型转换同上同上创建数组同上 stronglily: python numpy操作以及用pytorch在服务器训练模型中遇到的一些问题以及一些论文解释(conv-tasnet) scipy.signal的函数 Python保留两位...2023-08-03 05:03:202
骁龙8Gen1、天玑9000、苹果A15、谷歌Tensor性能测试,差距太明显
目前市面上的主流旗舰手机,无非是搭载了高通骁龙8Gen1芯片、天玑9000芯片、苹果A15仿生处理器、谷歌Tensor芯片,其中主流的旗舰手机搭载的骁龙8Gen1芯片和苹果A15仿生处理器这两款,并且深受消费者的欢迎。 而这四款芯片目前具备代表性的旗舰手机,分别为三星S22Ultra、红米K50Pro、iPhone13ProMax、谷歌Pixel6Pro,那么搭载这四款芯片的手机,在性能方面都有哪些差距呢,让我们一起来看下整个测试过程。 第一轮的测试环节,是在三星S22Ultra、红米K50Pro、iPhone13ProMax、谷歌Pixel6Pro这四部手机上,连续打开同样数量的软件,然后分别记录所耗费的时间。打开同样数量的软件,iPhone13ProMax耗费的时间最少,为1分35秒。第二名是三星S22Ultra,耗时为1分56秒。第三名是红米K50Pro,耗时为2分钟2秒。而谷歌Pixel6Pro排名第四,耗时为2分钟13秒。 在机身温度的表现方面,三星S22Ultra、红米K50Pro、iPhone13ProMax、谷歌Pixel6Pro的机身温度,分别为32 、33.6 、32.2 、32.3 ,三星S22Ultra的机身温度最低,红米K50Pro的机身温度最高。 第二轮测试环节是在三星S22Ultra、红米K50Pro、iPhone13ProMax、谷歌Pixel6Pro上运行软件的视频解码测试,这个测试环节也比较考验手机的性能表现。 从测试结果来看,视频解码速度最快的,是iPhone13ProMax,耗时20秒。视频解码排名第二的是三星S22Ultra,耗时30秒。视频解码速度排名第三的是红米K50Pro,耗时32秒。而视频解码速度垫底的是谷歌Pixel6Pro耗时36秒。 视频解码速度测试的结果和软件打开速度测试的结果基本上一致,这四部手机的排名在两个测试环节中也基本上一致。 第三个测试环节是运行软件解压缩测试,这四部手机对于软件解压缩的表现也完全不同。 软件解压缩排名第一的,依然是iPhone13ProMax,耗时为14秒。排名第二的是谷歌Pixel6Pro,耗时为19秒。第三名是三星S22Ultra,耗时为22秒。第四名则是红米K50Pro,耗时为25秒。 第三轮的测试结果发生了变化,谷歌Tensor处理器的表现跃居第二名,比第一轮和第二轮的测试环节表现都要出色。 最后一轮测试,是在三星S22Ultra、红米K50Pro、iPhone13ProMax、谷歌Pixel6Pro上运行GeekBench和安兔兔软件跑分。 GeekBench的跑分结果为,多核分别是3237分、4132分、4728分、2427分。安兔兔跑分测试结果为,904260分、961112分、813448分、589731分。 从两款不同的软件中的跑分可以看出来,这四部手机的跑分结果和排名也是完全不同,看样子这两款软件的侧重点也完全不同。 从多轮的测试结果来看,表现最好的依然是搭载苹果A15仿生处理器的iPhone13ProMax,除了安兔兔跑分的结果不高之外,在GeekBench的跑分和实际测试环节中的表现都非常优秀。所以如果预算充足的话,性能旗舰手机还是首选iPhone13ProMax,因为从使用体验上来看,iPhone13ProMax在多种测试环节中的表现是最好的,性能是最强的。2023-08-03 05:03:271
cv2本地图形读取,由RGB变为灰度,再变为tensor
最近想用pytorch识别本地的图片库,于是打算用一个最基础的网络,没有用到Conv 由cv2读取本地图形方式为: 第一行选取图形目录,cv2.IMREAD_GRAYSCALE为转为灰度 第二行为转为tensor形式,可以进入计算 基础的网络如下: 这里还需要一个y来表示样本的种类。 目前困惑 : 这里有个x,y的例子,但是x是每一行一个y对应,对于一个非向量的矩阵块,我还不明白怎么进行分类。 初步想法 : 如果有大佬看到希望能给予小白指导orz2023-08-03 05:03:341
tensorflow 怎么获取tensor 元素个数
sess.run( tf.size(tensor) )2023-08-03 05:03:433
tensorflow tensor shape依赖另外一个tensor值
一、环境TensorFlow API r1.12CUDA 9.2 V9.2.148cudnn64_7.dllPython 3.6.3Windows 10二、官方说明1、tf.shape(tensor)参数:input:张量或稀疏张量name:可选参数,操作的名称out_type:可选参数,指定输出张量的数据类型(int32 或 int64),默认是 tf.int32返回:指定 out_type 数据类型的张量2、tensor.shape张量的形状属性返回一个表示该张量的形状 tf.TensorShape对于每个操作,通过注册在 Op 中的形状推断函数来计算该张量的形状,形状表示的更多信息请参考 tf.TensorShape2023-08-03 05:03:501
我是做HPC的,Tensor Core在HPC中由于精度问题不专门使用就会浪费,那么,有没有办法把?
蓝海大脑高性能计算液冷服务器事业部杨博士:并不是Tensor Core在HPC应用里面,因为精度的关系用不上就是浪费,不管是FP64的Tensor Core还是更低精度的Tensor Core,有一些是直接就可以用起来,像64位的矩阵乘,如果HPC应用里面有大量的double矩阵乘,直接就可以获得很好的加速,精度也不会有任何的影响。甚至很多的HPC任务里面,用更低的精度做一些前期的快速迭代,之前应该是有很多的研究的文章,并不是Tensor Core在HPC应用里才能用起来,其实有很多的应用。另外也不能简简单单的理解成把一个FP32的矩阵乘能用几个FP16或其他精度的一些矩阵乘去做替代,好像数值上也是不可行的,它并不是一个简单的等价关系,而是从很多的迭代算法里面,用一些更低精度,其实可以对于更高精度可以做一些数值上的逼近。2023-08-03 05:03:571
谷歌Pixel折叠屏手机曝光:搭载三星Tensor G2处理器
眼看着市场上折叠屏手机越来越多,谷歌终于坐不住了。近日疑似谷歌折叠屏手机PixelFold被曝光,虽然说有就是好事,但这款手机的搭载的处理器却让人颇感意外。据悉,新款谷歌PixelFold折叠屏手机搭载的处理器参数与Pixel7系列上使用的TensorG2相同,TensorG2使用的是三星5nm制程工艺打造,在之前的曝光中,TensorG2的性能勉强与骁龙888持平,在游戏方面甚至只能对标骁龙870。PixelFold采用内外屏内折设计,内屏分辨率为1840*2208,尺寸为123mm*148mm,峰值亮度为1200尼特,平均亮度为800尼特,但不确定是否支持高刷新率。手机的后置影像模组与Pixel7系列保持统一风格,但并没有一直延伸到边缘,不过让人意外的是,手机共有两个9.5MP前置镜头。其他方面,PixelFold共有黑白两款,其定价为1799美元,约合12549.4元人民币,这个价和三星GalaxyFold4的定价一模一样。王者之心2点击试玩2023-08-03 05:04:051
tensorflow训练好的模型怎么调用
基本使用使用 TensorFlow, 你必须明白 TensorFlow:使用图 (graph) 来表示计算任务.在被称之为 会话 (Session) 的上下文 (context) 中执行图.使用 tensor 表示数据.通过 变量 (Variable) 维护状态.使用 feed 和 fetch 可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据.综述TensorFlow 是一个编程系统, 使用图来表示计算任务. 图中的节点被称之为 op(operation 的缩写). 一个 op 获得 0 个或多个 Tensor, 执行计算,产生 0 个或多个 Tensor. 每个 Tensor 是一个类型化的多维数组.例如, 你可以将一小组图像集表示为一个四维浮点数数组,这四个维度分别是 [batch, height, width, channels].一个 TensorFlow 图描述了计算的过程. 为了进行计算, 图必须在 会话 里被启动.会话 将图的 op 分发到诸如 CPU 或 GPU 之类的 设备 上, 同时提供执行 op 的方法.这些方法执行后, 将产生的 tensor 返回. 在 Python 语言中, 返回的 tensor 是numpy ndarray 对象; 在 C 和 C++ 语言中, 返回的 tensor 是tensorflow::Tensor 实例.计算图TensorFlow 程序通常被组织成一个构建阶段和一个执行阶段. 在构建阶段, op 的执行步骤被描述成一个图. 在执行阶段, 使用会话执行执行图中的 op.例如, 通常在构建阶段创建一个图来表示和训练神经网络, 然后在执行阶段反复执行图中的训练 op.TensorFlow 支持 C, C++, Python 编程语言. 目前, TensorFlow 的 Python 库更加易用,它提供了大量的辅助函数来简化构建图的工作, 这些函数尚未被 C 和 C++ 库支持.2023-08-03 05:04:281
多维情况下tensor的[-1]含义
见图,简单明了2023-08-03 05:04:421
求问怎么把一个tensor转换成一个array
import tensorflow as tf# 创建一个常量op, 产生一个1x2矩阵,这个op被作为一个节点# 加到默认视图中# 构造器的返回值代表该常量op的返回值matrix1 = tr.constant([[3., 3.]])# 创建另一个常量op, 产生一个2x1的矩阵matrix2 = tr.constant([[2.], [2.]])# 创建一个矩阵乘法matmul op,把matrix1和matrix2作为输入:product = tf.matmul(matrix1, matrix2)2023-08-03 05:04:491
张量tensor论文用什么字体表示
矢量用黑体;张量用简体2023-08-03 05:04:571
求问怎么把一个tensor转换成一个array
import tensorflow as tf# 创建一个常量op, 产生一个1x2矩阵,这个op被作为一个节点# 加到默认视图中# 构造器的返回值代表该常量op的返回值matrix1 = tr.constant([[3., 3.]])# 创建另一个常量op, 产生一个2x1的矩阵matrix2 = tr.constant([[2.], [2.]])# 创建一个矩阵乘法matmul op,把matrix1和matrix2作为输入:product = tf.matmul(matrix1, matrix2)2023-08-03 05:05:061
tensorflow 训练好的模型,怎么 调用
用tf.train.saver方法保存和恢复参数,然后运行一下图不更新参数就好了2023-08-03 05:05:175
Pytorch基本使用(2)Tensor转成one-hot形式
[1] 【Pytorch | Tensorflow】--- label与one-hot独热编码向量之间的相互转换 [2] Pytorch中,将label变成one hot编码的两种方式 [3] Pytorch中,将label变成one hot编码的两种方式 [4] Pytorch 类别标签转换one-hot编码2023-08-03 05:05:421
求问怎么把一个tensor转换成一个array
不知道是什么开发语言,JAVA中可以如下:List转换为Array可以这样处理:ArrayListlist=newArrayList();String[]strings=newString[list.size()];list.toArray(strings);反过来,如果要将数组转成List怎么呢?如下:String[]s={"a","b","c"};Listlist=java.util.Arrays.asList(s);2023-08-03 05:05:491
如何理解tensorflow中的dimension
基本使用使用 TensorFlow, 你必须明白 TensorFlow:使用图 (graph) 来表示计算任务。在被称之为 会话 (Session) 的上下文 (context) 中执行图。使用 tensor 表示数据。通过 变量 (Variable) 维护状态。使用 feed 和 fetch 可以为任意的操作(arbitrary operation) 赋值或者从其中获取数据。综述TensorFlow 是一个编程系统, 使用图来表示计算任务。 图中的节点被称之为 op(operation 的缩写)。 一个 op 获得 0 个或多个 Tensor, 执行计算,产生 0 个或多个 Tensor. 每个 Tensor 是一个类型化的多维数组。例如, 你可以将一小组图像集表示为一个四维浮点数数组,这四个维度分别是 [batch, height, width, channels].一个 TensorFlow 图描述了计算的过程。 为了进行计算, 图必须在 会话 里被启动。会话 将图的 op 分发到诸如 CPU 或 GPU 之类的 设备 上, 同时提供执行 op 的方法。这些方法执行后, 将产生的 tensor 返回。 在 Python 语言中, 返回的 tensor 是numpy ndarray 对象; 在 C 和 C++ 语言中, 返回的 tensor 是tensorflow::Tensor 实例。计算图TensorFlow 程序通常被组织成一个构建阶段和一个执行阶段。 在构建阶段, op 的执行步骤被描述成一个图。 在执行阶段, 使用会话执行执行图中的 op.例如, 通常在构建阶段创建一个图来表示和训练神经网络, 然后在执行阶段反复执行图中的训练 op.TensorFlow 支持 C, C++, Python 编程语言。 目前, TensorFlow 的 Python 库更加易用,它提供了大量的辅助函数来简化构建图的工作, 这些函数尚未被 C 和 C++ 库支持。三种语言的会话库 (session libraries) 是一致的。构建图构建图的第一步, 是创建源 op (source op)。 源 op 不需要任何输入, 例如 常量 (Constant)。 源 op 的输出被传递给其它 op 做运算。Python 库中, op 构造器的返回值代表被构造出的 op 的输出, 这些返回值可以传递给其它op 构造器作为输入。TensorFlow Python 库有一个默认图 (default graph), op 构造器可以为其增加节点。 这个默认图对许多程序来说已经足够用了。 阅读 Graph 类 文档2023-08-03 05:06:081
全连接层可以用gpu加速吗
梯度、全连接层、GPU加速、VisdomAshen_0nee 于2022-08-02 14:05:19pytorch机器学习深度学习文章目录前言一、常见函数的梯度二、激活函数及其梯度1、Sigmoid2、Tanh3、ReLU三、Loss 函数及其梯度1、Mean Squared Error(MSE)2、Softmax四、感知机的梯度1、单一输出感知机2、多输出感知机五、链式法则六、Multi-Layer Perceptron反向传播七、2D 函数优化实例八、交叉熵九、全连接层十、GPU 加速十一、MNIST 测试十二、Visdom 可视化前言本文为8月2日Pytorch笔记,分为十二个章节:常见函数的梯度:激活函数及其梯度:Sigmoid、Tanh、ReLU;Loss 函数及其梯度:MSE、Softmax;感知机的梯度:单一输出感知机、多输出感知机;链式法则;Multi-Layer Perceptron反向传播;2D 函数优化实例;交叉熵;全连接层;GPU 加速;MNIST 测试;Visdom 可视化。一、常见函数的梯度Function Derivativex sqrt x x u200b 1 2 x u2212 1 2 frac{1}{2}x^{-frac{1}{2}} 21u200bxu221221u200be x e^x ex e x e^x exa x a^x ax l n ( a ) a x ln(a)a^x ln(a)axl n ( x ) ln(x) ln(x) 1 x frac{1}{x} x1u200bl o g a ( x ) log_a(x) logau200b(x) 1 x l n ( a ) frac{1}{xln(a)} xln(a)1u200b二、激活函数及其梯度1、Sigmoidf ( x ) = σ ( x ) = 1 1 + e u2212 x f(x) = sigma (x) = frac{1}{1 + e^{-x}} f(x)=σ(x)=1+eu2212x1u200bσ ′ = σ ( 1 u2212 σ ) sigma" = sigma (1 - sigma) σ′=σ(1u2212σ)a = torch.linspace(-100, 100, 10)a>>> tensor([-100.0000, -77.7778, -55.5556, -33.3333, -11.1111, 11.1111, 33.3333, 55.5556, 77.7778, 100.0000])torch.sigmoid(a)>>> tensor([0.0000e+00, 1.6655e-34, 7.4564e-25, 3.3382e-15, 1.4945e-05, 9.9999e-01, 1.0000e+00, 1.0000e+00, 1.0000e+00, 1.0000e+00])2、Tanhf ( x ) = t a n h ( x ) = e x u2212 e u2212 x e x + e u2212 x = 2 s i g m o i d ( 2 x ) u2212 1 f(x) = tanh(x) = frac{e^x - e^{-x}}{e^x + e^{-x}} = 2sigmoid(2x) - 1 f(x)=tanh(x)=ex+eu2212xexu2212eu2212xu200b=2sigmoid(2x)u22121d d x t a n h ( x ) = 1 u2212 t a n h 2 ( x ) frac{d}{dx}tanh(x) = 1 - tanh^2(x) dxdu200btanh(x)=1u2212tanh2(x)a = torch.linspace(-1, 1, 10)a>>> tensor([-1.0000, -0.7778, -0.5556, -0.3333, -0.1111, 0.1111, 0.3333, 0.5556, 0.7778, 1.0000])torch.tanh(a)>>> tensor([-0.7616, -0.6514, -0.5047, -0.3215, -0.1107, 0.1107, 0.3215, 0.5047, 0.6514, 0.7616])3、ReLUf ( x ) = { 0 f o r x < 0 x f o r x ≥ 0 f(x) = egin{cases} 0quad for x < 0 \ xquad for x ge 0 end{cases} f(x)={0forx<0xforx≥0u200bf ′ ( x ) = { 0 f o r x < 0 1 f o r x ≥ 0 f"(x) = egin{cases} 0quad for x < 0 \ 1quad for x ge 0 end{cases} f′(x)={0for x<01for x≥0u200ba = torch.linspace(-1, 1, 10)a>>> tensor([-1.0000, -0.7778, -0.5556, -0.3333, -0.1111, 0.1111, 0.3333, 0.5556, 0.7778, 1.0000])torch.relu(a)>>> tensor([0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.1111, 0.3333, 0.5556, 0.7778, 1.0000])三、Loss 函数及其梯度1、Mean Squared Error(MSE)l o s s = ∑ [ y u2212 ( w x + b ) ] 2 = ∑ [ y u2212 ( f θ ( x ) ) ] 2 L 2 u2212 n o r m = ∣ ∣ y u2212 ( w x + b ) ∣ ∣ 2 loss = sum [y - (wx+b)]^2 = sum [y - (f_ heta (x))]^2\ L2 - norm = ||y - (wx+b)||_2 loss=∑[yu2212(wx+b)]2=∑[yu2212(fθu200b(x))]2L2u2212norm=∣∣yu2212(wx+b)∣∣2u200b▽ l o s s ▽ θ = 2 ∑ [ y u2212 f θ ( x ) ] u2217 ▽ f θ ( x ) ▽ θ frac{igtriangledown loss}{igtriangledown heta} = 2sum [y - f_ heta (x)] * frac{igtriangledown f_ heta(x)}{igtriangledown heta} ▽θ▽lossu200b=2∑[yu2212fθu200b(x)]u2217▽θ▽fθu200b(x)u200bautograd.grad:x = torch.ones(1)x>>> tensor([1.])w = torch.full([1], 2)w>>> tensor([2.])mse = F.mse_loss(torch.ones(1), x*w)mse>>> tensor(1.)w = torch.full([1], 2.)w.requires_grad_()>>> tensor([2.], requires_grad=True)mse = F.mse_loss(torch.ones(1), x*w)torch.autograd.grad(mse, [w])>>> (tensor([2.]),)2、Softmaxp i = e a i ∑ k = 1 N e a k p_i = frac{e^{a_i}}{ extstyle sum_{k=1}^{N} e^{a_k}} piu200b=∑k=1Nu200beaku200beaiu200bu200bu2202 p i u2202 a j = { p ) i ( 1 u2212 p ) i ) i f i = j u2212 p j u22c5 p i i f i ≠ j frac{partial p_i}{partial a_j} = egin{cases} p)i(1-p)i)quad ifquad i=j \ -p_jcdot p_iquad if quad i e j end{cases} u2202aju200bu2202piu200bu200b={p)i(1u2212p)i)ifi=ju2212pju200bu22c5piu200bifiue020=ju200ba = torch.rand(3)a>>> tensor([0.6954, 0.7334, 0.5293])a.requires_grad_()>>> tensor([0.6954, 0.7334, 0.5293], requires_grad=True)p = F.softmax(a, dim=0)p>>> tensor([0.3465, 0.3600, 0.2935], grad_fn=<SoftmaxBackward0>)torch.autograd.grad(p[1], [a], retain_graph=True)>>> (tensor([-0.1247, 0.2304, -0.1057]),)torch.autograd.grad(p[2], [a], retain_graph=True)>>> (tensor([-0.1017, -0.1057, 0.2074]),)四、感知机的梯度1、单一输出感知机x = torch.rand(1, 10)w = torch.rand(1, 10, requires_grad=True)o = torch.sigmoid(x @ w.t())o.shape>>> torch.Size([1, 1])loss = F.mse_loss(torch.ones(1, 1), o)loss.shape>>> torch.Size([])loss.backward()w.grad>>> tensor([[-0.0040, -0.0001, -0.0239, -0.0109, -0.0004, -0.0213, -0.0250, -0.0292, -0.0187, -0.0247]])2、多输出感知机x = torch.rand(1, 10)w = torch.rand(2, 10, requires_grad=True)o = torch.sigmoid(x @ w.t())o.shape>>> torch.Size([1, 2])loss = F.mse_loss(torch.ones(1, 2), o)loss>>> tensor(0.0048, grad_fn=<MseLossBackward0>)loss.backward()w.grad>>> tensor([[-0.0048, -0.0026, -0.0059, -0.0019, -0.0029, -0.0014, -0.0031, -0.0004, -0.0028, -0.0035], [-0.0024, -0.0013, -0.0029, -0.0010, -0.0015, -0.0007, -0.0016, -0.0002, -0.0014, -0.0017]])五、链式法则Function Derivativex n x^n xn n x n u2212 1 nx^{n-1} nxnu22121f g fg fg f g ′ + f ′ g fg" + f"g fg′+f′gf / g f/g f/g f ′ g u2212 g ′ f g 2 frac{f"g - g"f}{g^2} g2f′gu2212g′fu200bf ( g ( x ) ) f(g(x)) f(g(x)) f ′ ( g ( x ) ) g ′ ( x ) f"(g(x))g"(x) f′(g(x))g′(x)d y d x = d y d u d u d x frac{dy}{dx} = frac{dy}{du}frac{du}{dx} dxdyu200b=dudyu200bdxduu200bx = torch.tensor(1.)w1 = torch.tensor(2., requires_grad=True)b1 = torch.tensor(1.)w2 = torch.tensor(2., requires_grad=True)b2 = torch.tensor(1.)y1 = x*w1 + b1y2 = y1*w2 + b2dy2_dy1 = torch.autograd.grad(y2, [y1], retain_graph=True)[0]dy1_dw1 = torch.autograd.grad(y1, [w1], retain_graph=True)[0]dy2_dw1 = torch.autograd.grad(y2, [w1], retain_graph=True)[0]dy2_dy1 * dy1_dw1>>> tensor(2.)dy2_dw1>>> tensor(2.)六、Multi-Layer Perceptron反向传播For an output layer node k ∈ K : k in K: k∈K:u2202 E u2202 W j k = O j O k ( 1 u2212 O k ) ( O k u2212 t k ) frac{partial E}{partial W_{jk}} = O_jO_k(1-O_k)(O_k - t_k) u2202Wjku200bu2202Eu200b=Oju200bOku200b(1u2212Oku200b)(Oku200bu2212tku200b)For a hidden layer node j ∈ J : j in J: j∈J:u2202 E u2202 W i j = O i O j ( 1 u2212 O j ) ∑ k ∈ K O k ( 1 u2212 O k ) ( O k u2212 t k ) W j k frac{partial E}{partial W_{ij}} = O_iO_j(1 - O_j)sum_{k in K} O_k(1 - O_k)(O_k - t_k) W_{jk} u2202Wiju200bu2202Eu200b=Oiu200bOju200b(1u2212Oju200b)k∈K∑u200bOku200b(1u2212Oku200b)(Oku200bu2212tku200b)Wjku200b七、2D 函数优化实例Himmelblau function:f ( x , y ) = ( x 2 + y u2212 11 ) 2 + ( x + y 2 u2212 7 ) 2 f(x, y) = (x^2 + y -11)^2 + (x + y^2 - 7)^2 f(x,y)=(x2+yu221211)2+(x+y2u22127)2import torchimport numpy as npfrom matplotlib import pyplot as pltfrom mpl_toolkits.mplot3d import Axes3Ddef himmelblau(x): return (x[0] ** 2 + x[1] - 11) ** 2 + (x[0] + x[1] ** 2 - 7) ** 2x = np.arange(-6, 6, 0.1)y = np.arange(-6, 6, 0.1)print("x, y range: ", x.shape, y.shape)X, Y = np.meshgrid(x, y)print("X, Y maps: ", X.shape, Y.shape)Z = himmelblau([X, Y])fig = plt.figure("himmelblau")ax = fig.gca(projection="3d")ax.plot_surface(X, Y, Z)ax.view_init(60, -30)ax.set_xlabel("x")ax.set_ylabel("y")plt.show()# [1., 0.], [-4, 0.], [4, 0.]x = torch.tensor([-4., 0.], requires_grad=True)optimizer = torch.optim.Adam([x], lr=1e-3)for step in range(20000): pred = himmelblau(x) optimizer.zero_grad() pred.backward() optimizer.step() if step % 2000 == 0: print("step {}: x = {}, f(x) = {}" .format(step, x.tolist(), pred.item()))>>> x, y range: (120,) (120,) X, Y maps: (120, 120) (120, 120) step 0: x = [-3.999000072479248, -0.0009999999310821295], f(x) = 146.0 step 2000: x = [-3.526559829711914, -2.5002429485321045], f(x) = 19.4503231048584 step 4000: x = [-3.777446746826172, -3.2777843475341797], f(x) = 0.0012130826944485307 step 6000: x = [-3.7793045043945312, -3.283174753189087], f(x) = 5.636138666886836e-09 step 8000: x = [-3.779308319091797, -3.28318190574646], f(x) = 7.248672773130238e-10 step 10000: x = [-3.7793095111846924, -3.28318452835083], f(x) = 8.822098607197404e-11 step 12000: x = [-3.7793102264404297, -3.2831854820251465], f(x) = 8.185452315956354e-12 step 14000: x = [-3.7793102264404297, -3.2831859588623047], f(x) = 0.0 step 16000: x = [-3.7793102264404297, -3.2831859588623047], f(x) = 0.0 step 18000: x = [-3.7793102264404297, -3.2831859588623047], f(x) = 0.0八、交叉熵H ( p , q ) = ∑ p ( x ) l o g q ( x ) = H ( p ) + D K L ( p ∣ q ) H(p, q) = sum p(x)log q(x) = H(p) + D_{KL}(p|q) H(p,q)=∑p(x)log q(x)=H(p)+DKLu200b(p∣q)x = torch.randn(1, 784)w = torch.rand(10, 784)logits = x @ w.t()logits.shape>>> torch.Size([1, 10])pred = F.softmax(logits, dim=1)pred_log = torch.log(pred)F.cross_entropy(logits, torch.tensor([3]))>>> tensor(21.5533)F.nll_loss(pred_log, torch.tensor([3]))>>> tensor(21.5533)九、全连接层Network Architecture:# Network Architecturew1, b1 = torch.rand(200, 784, requires_grad=True), torch.zeros(200, requires_grad=True)w2, b2 = torch.rand(200, 200, requires_grad=True), torch.zeros(200, requires_grad=True)w3, b3 = torch.rand(10, 200, requires_grad=True), torch.zeros(10, requires_grad=True)# Trainoptimizer = optim.SGD([w1, b1, w2, b2, w3, b3], lr=learning_rate)criteon = nn.CrossEntropyLoss()for epoch in range(epochs): for batch_idx, (data, target) in enumerate(train_loader): data = data.view(-1, 28*28) logits = forward(data) loss = criteon(logits, target) optimizer.zero_grad() loss.backward() optimizer.step()nn.Linear:x = torch.rand(1, 784)x.shape>>> torch.Size([1, 784])layer1 = nn.Linear(784, 200)layer2 = nn.Linear(200, 200)layer3 = nn.Linear(200, 10)x = layer1(x)x.shape>>> torch.Size([1, 200])x = layer2(x)>>> x.shapetorch.Size([1, 200])x = layer3(x)x.shape>>> torch.Size([1, 10])x = F.relu(x, inplace=True)x.shape>>> torch.Size([1, 10])Implement forward():Step 1:class MLP(nn.Module): def __init__(self): super(MLP, self).__init__() self.model = nn.Sequential( nn.Linear(784, 200), nn.ReLU(inplace=True), nn.Linear(200, 200), nn.ReLU(inplace=True), nn.Linear(200, 10), nn.ReLU(inplace=True) )Step 2: def forward(self, x): x = self.model(x) return xTrain:net = MLP()optimizer = optim.SGD(net.parameters(), lr=learning_rate)criteon = nn.CrossEntropyLoss()for epoch in range(epochs): for batch_idx, (data, target) in enumerate(train_loader): data = data.view(-1, 28*28) logits = net(data) loss = criteon(logits, target) optimizer.zero_grad() loss.backward() optimizer.step()十、GPU 加速device = torch.device("cuda:0")net = MLP().to(device)optimizer = optim.SGD(net.parameters(), lr=learning_rate)criteon = nn.CrossEntropyLoss().to(device)for epoch in range(epochs): for batch_idx, (data, target) in enumerate(train_loader): data = data.view(-1, 28*28) data, target = data.to(device), target.to(device)十一、MNIST 测试 test_loss = 0 correct = 0 for data, target in test_loader: data = data.view(-1, 28*28) data, target = data.to(device), target.cuda() logits = net(data) test_loss += criteon(logits, target).item() pred = logits.data.max(1)[1] correct += pred.eq(target.data).sum() test_loss /= len(test_loader.dataset) print(" Test set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%) ".format( test_loss, correct, len(test_loader.dataset), 100. * correct / len(test_loader.dataset)))十二、Visdom 可视化viz.line([[test_loss, correct / len(test_loader.dataset)]], [global_step], win="test", update="append")viz.images(data.view(-1, 1, 28, 28), win="x")viz.text(str(pred.detach().cpu().numpy()), win="pred", opts=dict(title="pred"))2023-08-03 05:06:151
tensor flow如何保存模型
训练完一个模型后,为了以后重复使用,通常我们需要对模型的结果进行保存。如果用Tensorflow去实现神经网络,所要保存的就是神经网络中的各项权重值。建议可以使用Saver类保存和加载模型的结果。1、使用tf.train.Saver.save()方法保存模型sess: 用于保存变量操作的会话。save_path: String类型,用于指定训练结果的保存路径。global_step: 如果提供的话,这个数字会添加到save_path后面,用于构建checkpoint文件。这个参数有助于我们区分不同训练阶段的结果。2、使用tf.train.Saver.restore方法价值模型sess: 用于加载变量操作的会话。save_path: 同保存模型是用到的的save_path参数。下面通过一个代码演示这两个函数的使用方法假设保存变量的时候是checkpoint_filepath="models/train.ckpt"saver.save(session,checkpoint_filepath)则从文件读变量取值继续训练是saver.restore(session,checkpoint_filepath)2023-08-03 05:06:231
tensor.size()后面添加[0]表示什么?
无论怎样,都要相信自己前途无量2023-08-03 05:06:433
拍里奥的乒乓球胶皮
包括:德国套胶,正手套胶,龙系列,CJ8000系列,正贴套胶,长贴套胶等。拍里奥内能型套胶是胶皮、海绵和粘合剂工业制造技术的阶越式进步,弹性明显优于传统套胶,击球时有金属清脆悦耳的声音。拍里奥综合了德国先生TENSOR技术和中国主流打法的需求,增加了胶皮的粘性,扩大了海绵的适用硬度范围,创造了适合中国式打法的内能型套胶。 其中比较出名的有:电套胶类型:TENSOR 5G海绵硬度:47.5/42.5海绵厚度:2.15/2.0mm海绵产地:德国“电” 套胶―― 采用先迸德国内能Tensor 科技研发的中硬度海绵,体现速度、旋转及控球之完美结合,少于1ppm溶剂含量,符合国际乒联规定,无需使用任何膨胀剂。MAXIMO套胶类型:TENSOR 3G海绵硬度:42-43海绵厚度:2.0/2.2海绵产地:德国TENSOR 3G –含有比其他同类产品更大密度的网状分子结构,因而它可以释放出更大的能量,以及在比赛中使击球落点更精准。漂亮的快速胶水效果 --TENSOR 3G用新研发的海绵与胶皮粘合系统工艺制作,该工艺使化学溶剂具有畅通无阻的穿透力。即使是套胶的胶皮表面亦可感受到用快速胶水粘合后的完美效果。提高了海绵6%的弹性 -- 由于TENSOR 3G套胶所使用的海绵有着超薄间隔物的蜂窝状结构,伴随着其特有的活泼、高弹性的特质,使其自身内产生了一个气垫体。仪器检测的数据说,超过普通海绵6%的弹性在被撞击时释放出来。2023-08-03 05:06:501
下了一个tensor toolbox软件包,为什么在MATLAB中不能用
原因之一是因为没有把tensor toolbox 的路径加到matlab工具包下将tensor包拷贝到matlab的安装文件下的toolbox文件目录下,然后在matlab中运行addpath D:/MATLAB/toolbox/tensor toolbox(中间的目录依个人而定) ,然后运行 help ‘tensor",若成功则安装成功2023-08-03 05:07:041
谷歌全新Pixel平板电脑公布:Android系统+自研Tensor芯片
5月12日消息,今日凌晨,谷歌I/O2022开发者大会正式开幕。开发者大会上,谷歌接连发布了五款硬件新品,包括智能手机、智能手表、TWS耳机、平板电脑和一款概念AR眼镜。其中,谷歌Pixel平板电脑为娱乐用途设计,但需到2023年才会上市。这也是谷歌自2018年推出搭载Chrome操作系统的PixelSlate以来首次推出平板电脑。PixelSlate此前曾拥有后继机型,但谷歌随后表示将停止平板电脑的计划。在此之前,最后一款运行Android系统的谷歌平板电脑是2015年推出的PixelC。谷歌表示,计划让这款Pixel平板电脑成为“Pixel手机的完美伴侣”。此外,2023款Pixel平板电脑将与手机一样搭载GoogleTensor芯片。不过,谷歌并未透露这款平板电脑的价格。预告图显示,Pixel平板电脑正面采用白色边框,搭配后置单摄设计,谷歌G标识下方为四个白色触点,拥有灰白和绿灰两款配色。2023-08-03 05:07:131
利用CRNN来识别图片中的文字(二)tensorflow中ctc有关函数详解
定义一个稀疏tensor。 将一个稀疏tensor转换成稠密tensor。 计算ctc_loss。 主要参数1:labels: int32 SparseTensor 是数据的真实标签,一般是先用sparse_placeholder(),然后在session中feed训练数据batch_y。batch_y为 SparseTensor 利用sparse_tuple_from(y)函数计算得到。 sparse_tuple_from(y)函数的输入是在train_y中随机选择大小为 batch_size 的数据,输出是一个(indices, values, shape)形式的三元组。 主要参数2:inputs:是三维 float Tensor .logits是网络向前传播inference计算的结果。形状为[max_time_step, batch_size, num_classes]这里的num_classes是中文字典的大小,及992个汉字加1个空白,所以num_classes=993。输入图像经过卷积之后的大小为[batch_size, 11, 1, 512],max_time_step=512,是通道数,可以看作是512个图片特征序列。 主要参数3:sequence_length:一维 int32 向量【注意是向量,不是 Tensor !!!】长度为batch_size(批处理大小),值为max_len(ctc的最大输出长度,这个长度是自己定义的!合理即可!)的可以按照下面的方式定义。 占位符。在session中feed训练数据。2023-08-03 05:07:321
tensorflow如何查看模型的所有层的输入输出的tensor name
from tensorflow.python import pywrap_tensorflowimport osmodel_dir = "your model directory"checkpoint_path = os.path.join(model_dir, "model.ckpt")reader = pywrap_tensorflow.NewCheckpointReader(checkpoint_path)var_to_shape_map = reader.get_variable_to_shape_map()for key in var_to_shape_map:print("tensor_name: ", key)#print(reader.get_tensor(key)) # Remove this if you want to print only variable names2023-08-03 05:07:422