Tensor and Variable

本文详细介绍了TensorFlow中的核心概念——张量与变量。包括张量的属性、形状、数据类型,以及如何创建和操作张量。同时,深入探讨了变量的创建和初始化过程,为深度学习和神经网络的构建提供了坚实的基础。
部署运行你感兴趣的模型镜像

Tensor and Variable

Tensor

Tensor是一个类,包含了属性和常用函数,一个Tensor对象主要包含以下三个部分,如下所示:

Tensor("Placeholder:0", shape=(2, 3), dtype=float32)	

参数说明:

  • 第一部分是Tensor Name,比如:’Constant’、‘Placeholder’、‘Variable’等,0没有什么实质性的含义,只是表示Tensor的顺序,当前是0,那么下一个Tensor就是1了;

  • 第二部分是Tensor Shape, 也就是Tensor的形状,这里是[2,3],2行3列。

  • 第三部分是Tensor Type,也就是tensor张量的数据类型。

tensor的形状

tensor的形状,我们在TensorFlow中使用阶乘表示,它的形状表示如下表所示:

阶乘名称描述示例
0纯量只有大小s = 481
1向量有大小和方向v = [1, 2, 3]
2矩阵数据表比如:3x2矩阵,m = [[1,2] [3,4] [5,6]]
33阶张量数据立体比如:1x2x2,t = [[ [[1,2], [3,4]], [[5,6], [7,8]] ]]
nn阶张量n阶张量

在Tensorflow中,矩阵[n,m],表示n行m列,行表示特征数量,列表示样本数量。

tensor的数据类型

Python类型描述
tf.float6464位浮点数
tf.float3232位浮点数
tf.int6464位有符号整型
tf.int3232位有符号整型
tf.int1616位有符号整型
tf.int88位有符号整型
tf.uint88位无符号整型
tf.string可变长度的字节数组,每一个张量元素都是一个字节数组
tf.bool布尔型
tf.complex64由两个32位浮点数组成的复数:实数和虚数
tf.qint32用于量化Ops的32位有符号整型
tf.qint8用于量化Ops的8位有符号整型
tf.quint8用于量化Ops的8位无符号整型

float32和float64表示浮点精度,但是实际并不会多分配内存,两者的使用效果差不多,我们常用float32。同理int32和int64也是这样。

tensor属性

tensor对象具有如下属性:

  • graph:张量所在的图

  • op:张量的op

  • name:张量的名称

  • shape:张量的形状

示例代码:

import tensorflow as tf

a = tf.constant(1.0)

with tf.Session() as sess:
    print("graph-->", a.graph)
    print("op-->",a.op)
    print("name-->",a.name)
    print("shape-->",a.shape)

placeholder

placeholder是占位符张量。

我们可以通过tf.placeholder()来创建一个占位符张量,用于在运行图的时候,可以动态赋予数据,我们通过run(fetches, feed_dict=None, graph=None)来动态赋予数据。

示例代码:

import tensorflow as tf

plt = tf.placeholder(tf.float32, [2,3])

with tf.Session() as sess:
    sess.run(plt, feed_dict={
        plt: [[1, 2, 3],[3, 4, 5]]
    })

张量的静态形状和动态形状

静态形状

张量的形状在整个图中都是固定不可变的,如果初始的张量中由不确定的形状(如?),我们可以通过set_shape()去设置,通过get_shape()去获取

示例代码:

import tensorflow as tf

plt = tf.placeholder(tf.float32, [None,2])
# 列已经确定了,不能修改,行是None不确定可以修改
plt.set_shape([3,2])
print(plt.get_shape())

动态形状

一种描述原始张量在执行过程中的一种形状,这个张量的形状在图的执行过程中是可以动态改变的。更新动态形状:tf.reshape()

示例代码:

import tensorflow as tf

plt = tf.placeholder(tf.float32, [3,2])

# reshape重新创建一个张量
plt2 = tf.reshape(plt, [2,3])
print(plt2)

注意reshape前后的张量数据个数肯定是不能变的。

随机张量

在做神经网络训练的时候,梯度下降的初始参数w、b我们可以使用随机张量,然后通过梯度下降去优化。

以下是从正态分布创建随机张量的例子:

示例代码:

tf.random_normal(shape, mean=0.0, stddev=1.0, dtype=tf.float32,seed=None, name=None)

我们关注2个参数,mean表示数据平均值,也就是数学中的μ,stddev表示标准差,也就是数学中的σ。

当μ=0,σ=1时,也就是标准正态分布。

张量类型转换

例如,如果我们的张量的dtype是tf.int32类型的,我们可以将其转换为tf.float32类型的。

示例代码:

a = tf.constant(1.0)
b = tf.cast(a, tf.int32)

张量合并

示例代码:

import tensorflow as tf

b = [[1,2,3],[4,5,6]]
c = [[7,8,9],[10,11,12]]
# 张量合并
d = tf.concat([b,c], axis=0)

with tf.Session() as sess:
    print(d.eval())

运行结果如下:

[[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]	

说明:axis=0表示按行合并,axis=1表示按列合并。

Variable

variable 变量也是一种OP,是一种特殊的张量,能够进行存储持久化。

Variable的创建

API

tf.Variable(initial_value=None,name=None)

代码中涉及到了变量,一定要在Session之前做变量初始化,然后在Session中首先运行初始化的变量。

示例代码:

import tensorflow as tf
import os
os.environ['TP_CPP_LOG_LEVEL'] = '2'

# 创建变量
val = tf.Variable(tf.random_normal([2,3], mean=0.0, stddev=1.0))

# 变量初始化
init_op = tf.global_variables_initializer()

with tf.Session() as sess:
    # 运行变量初始化op
    sess.run(init_op)

    # 输出变量
    print(sess.run(val))

我们在会话前必须做变量的初始化成一个op,然后在会话中首先运行这个初始化变量

我们也可以采用下面的简化方式:

with tf.Session() as sess:
   sess.run(tf.global_variables_initializer())

您可能感兴趣的与本文相关的镜像

TensorFlow-v2.15

TensorFlow-v2.15

TensorFlow

TensorFlow 是由Google Brain 团队开发的开源机器学习框架,广泛应用于深度学习研究和生产环境。 它提供了一个灵活的平台,用于构建和训练各种机器学习模型

### 关于张量分解的实现 #### 使用NumPy进行张量分解 在Python中,可以利用`NumPy`库来执行基本的矩阵操作并扩展至多维数组(即张量)。一种常见的张量分解方法是CANDECOMP/PARAFAC (CP) 分解。虽然`NumPy`本身不直接提供高级别的张量分解函数,但可以通过组合其基础功能手动实现简单的张量分解算法。 以下是基于`NumPy`的一个简单CP分解示例[^4]: ```python import numpy as np from scipy.optimize import minimize def cp_decomposition(tensor, rank): """ Perform CP Decomposition using alternating least squares. Parameters: tensor: Input tensor (multi-dimensional array). rank: Rank of the decomposition. Returns: Factors matrices A, B, C corresponding to each mode. """ dims = tensor.shape factors = [np.random.rand(dims[i], rank) for i in range(len(dims))] def reconstruction_error(factors_flat): nonlocal factors start_idx = 0 for i in range(len(dims)): end_idx = start_idx + dims[i]*rank factors[i] = factors_flat[start_idx:end_idx].reshape((dims[i], rank)) start_idx = end_idx reconstructed_tensor = np.einsum('ar,br,cr->abc', *factors) error = np.linalg.norm(reconstructed_tensor - tensor) return error initial_guess = np.concatenate([factor.flatten() for factor in factors]) result = minimize(reconstruction_error, initial_guess, method='L-BFGS-B') optimal_factors = result.x start_idx = 0 for i in range(len(dims)): end_idx = start_idx + dims[i]*rank factors[i] = optimal_factors[start_idx:end_idx].reshape((dims[i], rank)) start_idx = end_idx return factors # Example usage tensor = np.random.rand(10, 10, 10) rank = 3 A, B, C = cp_decomposition(tensor, rank) ``` 此代码片段展示了如何通过交替最小二乘法(ALS)实现CP分解,并使用`scipy.optimize.minimize`优化重建误差[^4]。 --- #### 使用TensorFlow进行张量分解 对于更复杂的场景,推荐使用专门设计用于高效计算的框架如`TensorFlow`。该框架内置了一些工具支持张量运算以及自动微分等功能,从而简化了复杂模型构建过程中的工作负担。下面是一个基于`TensorFlow`版本的例子[^5]: ```python import tensorflow as tf def tucker_decomposition(tensor, ranks): """ Perform Tucker Decomposition on an input tensor. Parameters: tensor: Input tensor (multi-dimensional array). ranks: List specifying core tensor dimensions after compression. Returns: Core tensor and projection matrices along all modes. """ init_core = tf.keras.initializers.RandomUniform() core_tensor = tf.Variable(init_core(shape=ranks), trainable=True) projections = [] for dim_size, rank in zip(tf.shape(tensor).numpy(), ranks): proj_matrix = tf.Variable( tf.keras.initializers.GlorotNormal()(shape=(dim_size, rank)), trainable=True ) projections.append(proj_matrix) @tf.function def loss(): approximated_tensor = tf.tensordot(core_tensor, projections[0], axes=([0],[0])) for idx in range(1, len(projections)): approximated_tensor = tf.tensordot(approximated_tensor, projections[idx], axes=([idx], [0])) return tf.reduce_mean((approximated_tensor - tensor)**2) optimizer = tf.optimizers.Adam() for _ in range(100): # Number of iterations can be adjusted based on convergence criteria with tf.GradientTape() as tape: current_loss = loss() grads = tape.gradient(current_loss, [core_tensor] + projections) optimizer.apply_gradients(zip(grads, [core_tensor] + projections)) return core_tensor.numpy(), [p.numpy() for p in projections] # Example Usage input_tensor = tf.random.uniform(shape=[8, 8, 8]) ranks = [3, 3, 3] core, projections = tucker_decomposition(input_tensor, ranks) print("Core Tensor Shape:", core.shape) for i, proj in enumerate(projections): print(f"Projection Matrix {i} Shape:", proj.shape) ``` 上述脚本实现了Tucker分解——另一种重要的张量压缩技术,在这里我们定义了一个损失函数并通过梯度下降调整参数直至收敛[^5]。 --- ### 总结 无论是采用通用科学计算包还是深度学习专用软件栈都可以完成不同类型的张量分析任务;前者适合快速原型开发而后者则更适合大规模分布式训练环境下的应用需求。选择合适的解决方案取决于具体应用场景的要求及其规模特性等因素影响。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值