两个 vector 的内积是对应元素的乘积之和。为了能够得到内积，vector 的长度必须相同。内积是矩阵算术的基本运算。两个矩阵的乘积是一个矩阵，它是由第一个矩阵的每一行乘以第二个矩阵的每一列得到的，如图 1 所示。
图 1 矩阵乘法和内积运算
为了使矩阵内积成为可能，左操作数(矩阵 A)的列数必须和右操作数(矩阵 B)的行数相同。如果左操作数有 m 行和 n 列(mxn 的矩阵)，右操作数有 n 行和 k 列(nxk 的矩阵)，结果是一个 m 行和 k 列的矩阵(mxk 的矩阵)。
定义在 numeric 头文件中的 inner_product() 算法可以计算两个 vector 的内积。这个函数模板有 4 个参数：前两个参数是定义第 1 个 vector 的输入迭代器，第 3 个参数是确定第 2 个 vector 的开始输入迭代器，第 4 个参数是和的初值。算法会返回 vector 的内积。例如：
std::vector v1(10);
std::vector v2(10);
std::iota(std::begin(v1), std::end(v1), 2); // 2 3 4 5 6 7 8 9 10 11
std::iota (std::begin(v2) , std::end(v2),3); // 3 4 5 6 7 8 9 10 11 12
std::cout << std::inner_product(std::begin(v1), std::end(v1), std::begin(v2),0)<
因为两个 vector 的内积的标准定义，内积的初值为 0，但可以选择为对应元素的乘积 之和指定不同的初值。在使用 inner_product() 时，使用正确的类型很重要，如下所示：
std::vector data {0.5, 0.75, 0.85};
auto resultl = std::inner_product(std::begin(data), std::end(data), std::begin(data),0)；
double result2 = std::inner_product(std:rbegin(data),std::end(data), std:: begin(data), 0);
auto result3 = std::inner_product(std::begin(data), std::end(data), std:rbegin(data)r 0.0);
std::cout << resultl << " "<
第二条和第三条语句显然做的是同样的事，但返回的类型是由第 4 个参数决定的。即使迭代器指向的是浮点参数，当内积的初值是整数类型时，对应元素相乘的结果的组合运算适用的是整数运算。这同样适用于 accumulate() 算法，因此需要保证内积的初值是合适的类型。幸运的是，当初值的类型和这个运算所涉及的元素不同时，大多数编译器会发出警告。我们可以在一个示例中尝试使用 inner_product() 算法和其他的一些算法。
应用内积
最小二乘线性回归是求系数的一种方法，对于 a、b、y=ax+b，这最适合通过一组点 (x,y)，这些点通常是现实世界中的某种数据样本。这个方法来自高斯，找到 a 和 6 的系数，这样样本点到行的垂直距离平方和是最小的。下面介绍一个可以做到这些的等式，不需要知道这些等式是如何得到的，但是如果不想和任何数学打交道，可以跳过它直接看代码。
给定 n 个点 (xi,yi)，这个方法涉及求解下面的等式：
解出等式的系数 a 和 b：
如果能随着 x 和 y 的平均值计算出各种和，就能将它代入这些方程中，得到回归直线的系数。前面章节介绍过，变量 x 的 n 个值的平均值 u 的等式是：
显然，accumulate() 和 inner_product() 算法对这些是非常有帮助的。
这个示例会生成与从文件中得到的一组数据点相拟合的直线。文件在下载的代码中，记录了每千瓦时的耗电成本和欧洲几个国家平均每人的可再生能源发电装机瓦数。程序的输出应该显示配置的可再生能源的容量和成本是否是线性关系。下面是代码：
// Least squares regression
#include                                        // For accumulate(), inner_product()
#include                                         // For vector container
#include                                       // For standard streams
#include                                        // For stream manipulators
#include                                        // For file streams
#include                                       // For iterators and begin() and end()
#include                                         // For string class
using std::string;
int main()
{
// File contains country_name renewables_per_person kwh_cost
string file_in {"G:/Beginning_STL/renewables_vs_kwh_cost.txt"};
std::ifstream in {file_in};
if(!in)                                       // Verify  we have a file
{
std::cerr << file_in << " not open." << std::endl;
exit(1);
}
std::vector x;                        // Renewables per head
std::vector y;                        // Corresponding cost for a kilowatt hour
// Read the file and show the data
std::cout << "   Country   " << " Watts per Head " << " kwh cost(cents) " << std::endl;
while(true)
{
string country;
double renewables {};
double kwh_cost {};
if((in >> country).eof()) break;                           // EOF read - we are done
in >> renewables >> kwh_cost;
x.push_back(renewables);
y.push_back(kwh_cost);
std::cout << std::left << std::setw(12) << country<< std::right<< std::fixed << std::setprecision(2) << std::setw(12) << renewables
<< std::setw(16) << kwh_cost << std::endl;
}
auto n = x.size();                                            // Number of points
auto sx = std::accumulate(std::begin(x), std::end(x), 0.0);   // Sum of x values
auto sy = std::accumulate(std::begin(y), std::end(y), 0.0);   // Sum of y values
auto mean_x = sx/n;                                           // Mean of x values
auto mean_y = sy/n;                                           // Mean of y values
// Sum of x*y values and sum of x-squared
auto sxy = std::inner_product(std::begin(x), std::end(x), std::begin(y), 0.0);
auto sx_2 = std::inner_product(std::begin(x), std::end(x), std::begin(x), 0.0);
double a {}, b {};                                            // Line coefficients
auto num = n*sxy - sx*sy;                                     // Numerator for a
auto denom = n*sx_2 - sx*sx;                                  // Denominator for a
a = num / denom;
b = mean_y - a*mean_x;
std::cout << std:: fixed << std::setprecision(3) << "\ny = "<< a << "*x + " << b << std::endl;
}
在 while 循环中读取了文件。只保存数值，每一个都完整记录了国家名称、人均新再生能源装机量的瓦特数，每千瓦时花费的成本则以美分的形式被写到标准输出流中。对于保存在 vector 容器中的两个值；x 记录的是每个国家人均的可再生容量，记录的是对应的千瓦时的成本。
x 和 y 的平均值是由 accumulate() 算法通过算出每个容器中的元素之和计算得出的，然后用结果除以元素的个数。x 的平方之和与 xy 的内积之和是通过 innier_product() 算法计算得出的。通过使用前面展示的等式，可以用这些结果算出直线的系数 a 和 b。
注意，可以简化系数 a 的等式。如果将分母和分子除以 n2，等式就可以写为：
现在 x 的值和的值不再显式需要了。计算系数的代码可以写为：
auto n = x.size(); // Number of points
//Calculate mean values for x, y, xy, and x一squared
auto mean_x = std::accumulate(std::begin(x), std::end(x), 0.0);
auto mean_y = std::accumulate(std::begin(y), std::end(y), 0.0);
auto mean_xy = std::inner_product(std::begin(x), std::end(x),std::begin (y), 0.0);
auto mean_x2 = std::inner_product(std::begin(x), std::end(x), std::begin(x), 0.0);
//Calculate coefficients
auto a = (mean_xy - mean_x*mean_y)/(mean_x2-mean_x*mean_x);
auto b = mean_y - a*mean_x;
这里用更少的代码实现了相同的结果。图 2 的右边显示了程序的输出，左边是回归直线和原始数据点的图形。
图 2 最小二乘线性回归的结果(点此查看大图)
绘制的图形相当有说服力(原始点很接近它)。看起来好像人均每增加 100 瓦的可再生能源发电量，每千瓦时需要付出几乎两美分的成本。
定义内积运算
之前见到的 inner_product() 版本将两个输入序列的对应元素相乘，然后算出总数。第二个版本有两个以上的定义函数对象的参数。第二个函数对象定义了运用到两个序列中对应元素的二元运算，以及第一个用来代替加法合并结果的二元运算。我们提供的作为参数的函数对象不能使任何迭代器无效，也不能修改输入序列的元素。下面展示了如何生成和的积而不是积的和：
std::vector v1(5);
std::vector v2(5);
std::iota(std::begin(v1), std::end(v1), 2); // 2 3 4 5 6
std::iota(std::begin(v2), std::end(v2), 3);    // 3 4 5 6 7
std::cout << std:: inner_product (std::begin (v1), std: :end(v1), std::begin(v2), 1, std::multiplies<>(),std::plus <>())>>std::endl;    // Output: 45045
inner_product() 调用中，作为参数的函数对象被定义在 functional 头文件中。plus 对象会计算出两个 T 类型值的和，这里定义运算的模板实例会被应用到来自于输入序列的 int 类型的对应元素上。作为 inner_product() 的第 5 个参数的 multiples 实例，它会将乘法结果累计起来，注意因为结果是乘积，如果不想结果总是为 0，初值必须不为 0。
Functional 头文件中也定义了可以用于 inner_product() 的其他二元算术运算(减、除、求余)。也可以用定义了位运算的函数对象的模板，它们是 bit_and、bit_or、bit_eor。

首先，tensorflow并不神秘，基本相当于numpy和各种model的一个集合，另外比numpy多了两个功能：求张量和求导。numpy的数据组织模式很容易就能转换成tensorflow的数据组织模式，可以作为tensorflow的输入。
在tensorflow中计算矩阵相乘、点乘（内积）、卷积的方法demo。输入数据均使用numpy生成随机多维数组。
并比较numpy点乘和tensorflow点乘的区别，了解输入输出矩阵的shape。
# coding:utf-8

import tensorflow as tf
import numpy as np
import pandas as pd
import time

# 用numpy创建一个 10x5 矩阵
# 加到默认图中.

a = np.random.random((10, 5))
print(a)
# b = []
# b.append(list(a))
matrix1 = tf.convert_to_tensor(a)  # 用于计算相乘和点乘（内积）的矩阵
matrix0 = tf.constant(a, shape=[1, 10, 5, 1])  # 用于计算卷积的矩阵，输入一样，但需要指定特殊的shape
print(matrix0)
print(matrix1)
# exit()
b = np.random.random((5, 3))  # 计算矩阵相乘的矩阵shape
print(b)
c = np.random.random((1, 5))  # 计算内积（矩阵点乘）的矩阵shape
print(c)
matrix2 = tf.convert_to_tensor(b)
print(matrix2)
matrix3 = tf.convert_to_tensor(c)
print(matrix3)
kernel_0 = tf.constant(b, shape=[5, 3, 1, 1])  # 用于计算卷积的矩阵，输入一样，但需要指定特殊的shape

product_0 = tf.matmul(matrix1, matrix2)  # 矩阵相乘
product_1 = tf.multiply(matrix1, matrix3)  # 矩阵点乘（内积）
conv2d = tf.nn.conv2d(matrix0, kernel_0, strides=[1, 1, 1, 1], padding='SAME')  # 卷积
# numpy的点乘（内积）和tensorflow的点乘（内积）稍有区别，numpy是点乘完后按行求和
df = pd.DataFrame(a)
score = np.dot(df, c[0])
print(score, np.shape(score))
# 启动默认图，执行这个乘法操作,并计算耗时
with tf.Session() as sess:
    tic = time.time()
    result_0 = sess.run([product_0])
    result_1 = sess.run([product_1])
    result_2 = sess.run([conv2d])
    print(result_0, np.shape(result_0))
    print(result_1, np.shape(result_1))
    print(result_2, np.shape(result_2))
    toc = time.time()
    print('time cost：'+str(1000*(toc - tic)))

两个 vector 的内积是对应元素的乘积之和。为了能够得到内积，vector 的长度必须相同。内积是矩阵算术的基本运算。两个矩阵的乘积是一个矩阵，它是由第一个矩阵的每一行乘以第二个矩阵的每一列得到的，如图 1 所示。




图 1 矩阵乘法和内积运算



为了使矩阵内积成为可能，左操作数（矩阵 A）的列数必须和右操作数（矩阵 B）的行数相同。如果左操作数有 m 行和 n 列（mxn 的矩阵），右操作数有 n 行和 k 列（nxk 的矩阵），结果是一个 m 行和 k 列的矩阵（mxk 的矩阵）。


定义在 numeric 头文件中的 inner_product() 算法可以计算两个 vector 的内积。这个函数模板有 4 个参数：前两个参数是定义第 1 个 vector 的输入迭代器，第 3 个参数是确定第 2 个 vector 的开始输入迭代器，第 4 个参数是和的初值。算法会返回 vector 的内积。例如：


 

std::vector<int> v1(10);
	
std::vector<int> v2(10);
	
std::iota(std::begin(v1), std::end(v1), 2); // 2 3 4 5 6 7 8 9 10 11
	
std::iota (std::begin(v2) , std::end(v2),3); // 3 4 5 6 7 8 9 10 11 12
	
std::cout << std::inner_product(std::begin(v1), std::end(v1), std::begin(v2),0)<<std:rendl; // Output: 570
因为两个 vector 的内积的标准定义，内积的初值为 0，但可以选择为对应元素的乘积 之和指定不同的初值。在使用 inner_product() 时，使用正确的类型很重要，如下所示：


 

std::vector<double> data {0.5, 0.75, 0.85};
	
auto resultl = std::inner_product(std::begin(data), std::end(data), std::begin(data),0)；
	
double result2 = std::inner_product(std:rbegin(data),std::end(data), std:: begin(data), 0);
	
auto result3 = std::inner_product(std::begin(data), std::end(data), std:rbegin(data)r 0.0);
	
std::cout << resultl << " "<<result2<< " " << result3 <<std:: endl; // Output: 0 0 1.535
第二条和第三条语句显然做的是同样的事，但返回的类型是由第 4 个参数决定的。即使迭代器指向的是浮点参数，当内积的初值是整数类型时，对应元素相乘的结果的组合运算适用的是整数运算。这同样适用于 accumulate() 算法，因此需要保证内积的初值是合适的类型。幸运的是，当初值的类型和这个运算所涉及的元素不同时，大多数编译器会发出警告。我们可以在一个示例中尝试使用 inner_product() 算法和其他的一些算法。

应用内积

最小二乘线性回归是求系数的一种方法，对于 a、b、y=ax+b，这最适合通过一组点 (x,y)，这些点通常是现实世界中的某种数据样本。这个方法来自高斯，找到 a 和 6 的系数，这样样本点到行的垂直距离平方和是最小的。下面介绍一个可以做到这些的等式，不需要知道这些等式是如何得到的，但是如果不想和任何数学打交道，可以跳过它直接看代码。


给定 n 个点 (xi,yi)，这个方法涉及求解下面的等式：




 

解出等式的系数 a 和 b：




 

如果能随着 x 和 y 的平均值计算出各种和，就能将它代入这些方程中，得到回归直线的系数。前面章节介绍过，变量 x 的 n 个值的平均值 u 的等式是：




显然，accumulate() 和 inner_product() 算法对这些是非常有帮助的。


这个示例会生成与从文件中得到的一组数据点相拟合的直线。文件在下载的代码中，记录了每千瓦时的耗电成本和欧洲几个国家平均每人的可再生能源发电装机瓦数。程序的输出应该显示配置的可再生能源的容量和成本是否是线性关系。下面是代码：


 

// Least squares regression
	
#include <numeric> // For accumulate(), inner_product()
	
#include <vector> // For vector container
	
#include <iostream> // For standard streams
	
#include <iomanip> // For stream manipulators
	
#include <fstream> // For file streams
	
#include <iterator> // For iterators and begin() and end()
	
#include <string> // For string class
	
using std::string;
	
 
	
int main()
	
{
	
// File contains country_name renewables_per_person kwh_cost
	
string file_in {"G:/Beginning_STL/renewables_vs_kwh_cost.txt"};
	
std::ifstream in {file_in};
	
if(!in) // Verify we have a file
	
{
	
std::cerr << file_in << " not open." << std::endl;
	
exit(1);
	
}
	
 
	
std::vector<double> x; // Renewables per head
	
std::vector<double> y; // Corresponding cost for a kilowatt hour
	
 
	
// Read the file and show the data
	
std::cout << " Country " << " Watts per Head " << " kwh cost(cents) " << std::endl;
	
while(true)
	
{
	
string country;
	
double renewables {};
	
double kwh_cost {};
	
 
	
if((in >> country).eof()) break; // EOF read - we are done
	
in >> renewables >> kwh_cost;
	
x.push_back(renewables);
	
y.push_back(kwh_cost);
	
std::cout << std::left << std::setw(12) << country<< std::right<< std::fixed << std::setprecision(2) << std::setw(12) << renewables
	
<< std::setw(16) << kwh_cost << std::endl;
	
}
	
 
	
auto n = x.size(); // Number of points
	
auto sx = std::accumulate(std::begin(x), std::end(x), 0.0); // Sum of x values
	
auto sy = std::accumulate(std::begin(y), std::end(y), 0.0); // Sum of y values
	
auto mean_x = sx/n; // Mean of x values
	
auto mean_y = sy/n; // Mean of y values
	
 
	
// Sum of x*y values and sum of x-squared
	
auto sxy = std::inner_product(std::begin(x), std::end(x), std::begin(y), 0.0);
	
auto sx_2 = std::inner_product(std::begin(x), std::end(x), std::begin(x), 0.0);
	
 
	
double a {}, b {}; // Line coefficients
	
auto num = n*sxy - sx*sy; // Numerator for a
	
auto denom = n*sx_2 - sx*sx; // Denominator for a
	
a = num / denom;
	
b = mean_y - a*mean_x;
	
std::cout << std:: fixed << std::setprecision(3) << "\ny = "<< a << "*x + " << b << std::endl;
	
}
在 while 循环中读取了文件。只保存数值，每一个都完整记录了国家名称、人均新再生能源装机量的瓦特数，每千瓦时花费的成本则以美分的形式被写到标准输出流中。对于保存在 vector 容器中的两个值；x 记录的是每个国家人均的可再生容量，记录的是对应的千瓦时的成本。


x 和 y 的平均值是由 accumulate() 算法通过算出每个容器中的元素之和计算得出的，然后用结果除以元素的个数。x 的平方之和与 xy 的内积之和是通过 innier_product() 算法计算得出的。通过使用前面展示的等式，可以用这些结果算出直线的系数 a 和 b。


注意，可以简化系数 a 的等式。如果将分母和分子除以 n2，等式就可以写为：






现在 x 的值和的值不再显式需要了。计算系数的代码可以写为：


 

auto n = x.size(); // Number of points
	
//Calculate mean values for x, y, xy, and x一squared
	
auto mean_x = std::accumulate(std::begin(x), std::end(x), 0.0);
	
auto mean_y = std::accumulate(std::begin(y), std::end(y), 0.0);
	
auto mean_xy = std::inner_product(std::begin(x), std::end(x),std::begin (y), 0.0);
	
auto mean_x2 = std::inner_product(std::begin(x), std::end(x), std::begin(x), 0.0);
	
//Calculate coefficients
	
auto a = (mean_xy - mean_x*mean_y)/(mean_x2-mean_x*mean_x);
	
auto b = mean_y - a*mean_x;
这里用更少的代码实现了相同的结果。图 2 的右边显示了程序的输出，左边是回归直线和原始数据点的图形。




图 2 最小二乘线性回归的结果（点此查看大图）



绘制的图形相当有说服力(原始点很接近它)。看起来好像人均每增加 100 瓦的可再生能源发电量，每千瓦时需要付出几乎两美分的成本。

定义内积运算

之前见到的 inner_product() 版本将两个输入序列的对应元素相乘，然后算出总数。第二个版本有两个以上的定义函数对象的参数。第二个函数对象定义了运用到两个序列中对应元素的二元运算，以及第一个用来代替加法合并结果的二元运算。我们提供的作为参数的函数对象不能使任何迭代器无效，也不能修改输入序列的元素。下面展示了如何生成和的积而不是积的和：


 

std::vector<int> v1(5);
	
std::vector<int> v2(5);
	
std::iota(std::begin(v1), std::end(v1), 2); // 2 3 4 5 6
	
std::iota(std::begin(v2), std::end(v2), 3); // 3 4 5 6 7
	
std::cout << std:: inner_product (std::begin (v1), std: :end(v1), std::begin(v2), 1, std::multiplies<>(),std::plus <>())>>std::endl; // Output: 45045
inner_product() 调用中，作为参数的函数对象被定义在 functional 头文件中。plus<T> 对象会计算出两个 T 类型值的和，这里定义运算的模板实例会被应用到来自于输入序列的 int 类型的对应元素上。作为 inner_product() 的第 5 个参数的 multiples 实例，它会将乘法结果累计起来，注意因为结果是乘积，如果不想结果总是为 0，初值必须不为 0。


Functional 头文件中也定义了可以用于 inner_product() 的其他二元算术运算（减、除、求余）。也可以用定义了位运算的函数对象的模板，它们是 bit_and、bit_or、bit_eor。

下面我们探讨矩阵张量积所蕴含的意义。将域 
 上的 
 维
方矩阵(phalanx)的集合记为 
 ，矩阵张量积的计算如下：
后面将看到，矩阵的张量积可以不限于方矩阵。
Hermite内积的张量表示
回顾一个过去多次讨论的例子，详细的推导见：
MP32：张量专题(1)：SO(2)和平面向量的张量 
MP86：辛(symplectic)的起源(1)：三角函数的线性性与Hermite内积 
MP87：辛(symplectic)的起源(2)：张量与Hermite内积的旋转不变量 
MP88：辛(symplectic)的起源(3)：辛矩阵 
过去 [MP32] 我们已经详细讨论了 
 对正交归一基的作用，从而构造逆变张量。现在我们直接用 
 作用于复数。
复数的Hermite内积 
 蕴含着与张量相关的性质：
其关键之处在于对第二个变元是共轭(conjugate)的，从而在复数乘法中得到了复向量的夹角。在(1)中，Hermite内积的实部为向量内积、虚部为向量外积：
内积和外积在Hermite内积中的统一(2)，让我们注意到它们都有统一的组成成分——由 
 个向量的分量交替相乘产生的 
 -次齐次项 
 。运用上面的矩阵张量积规则，可以将所有 
 -齐次项用一个列向量/张量表示：
把(2)写成对张量的线性映射，以便用线性映射的手法同时分析内积和外积：
张量积的实质是把双线性映射转化为一个单线性映射。上式已经体现出了这种转换的结构，即通过一个矩阵 
 将两个向量整体映射到Hermite内积。下面我们通过特殊正交群
对内积和外积——乃至Hermite内积的保持来阐述这一点。
 的张量
考虑特殊正交群
作为平面旋转群
对平面向量的作用：
从而导致(3)的变化，直接展开计算：
现在我们得到了基的变换下，合成向量的变换关系。(5)中 
 对两个向量分别进行的线性映射，在(6)中构成双线性映射。张量
 则直接作用于 
 构成对应于双线性映射的单线性映射，即结合(5)(6)的：
Hermite内积的 
 不变性
回到(4)中Hermite内积的张量表示，在(7)中 
 的作用下，有：
这里涉及到(4)和(6)中两个大的矩阵的乘法：
带入(8)证得
即二维Hermite内积在 
 作用下不变。
典型群的张量
前面的讨论让我们熟悉如何利用张量的手法来处理不变性问题，这样既有详尽的计算，又有直观的理解。现在我们站在一般的典型群，主要是可以矩阵表示的 
 的Lie子群上考虑问题，这类Lie群可以视为线性空间上的算子群，在物理上有极为广泛的应用——如规范场。经过上面的讨论，我们可以对类似问题有一个一般的处理思路：将(5)拓展开，给定作用于两个线性空间的两个Lie群 
 和 
 ，群元 
 作用于 
 ，
 作用于 
都是线性的：
前面例子中原始的Hermite内积(2)体现了如下结构的双线性映射：
而(4)则体现了将双线性映射转化为对张量积的单线性映射，线性空间中可以用矩阵 
 表示（无穷维线性空间则是算子）：
类似前面的讨论，当Lie群以(9)线性作用时，(10)和(11)相应变成
上式中，第一行的双线性方式需要处理两个变量，而第二行的单线性映射直接操作张量，是现代数学物理常用的方法，其要点如同我们在(6)(7)所体验到的，在于借助Lie群本身的张量积 
 来构造对张量空间 
 的单线性变换：
现在回到最初的矩阵乘法。上面我们没有限定线性空间和Lie群的类型。若 
 以及 
 ，那么作为可以用矩阵表示的典型群有 
 及 
 ，其矩阵表示的张量就是矩阵张量积 
 ，从(11)中线性映射的角度看， 
 ，而矩阵张量积 
 就是 
 上的线性变换(13)。
矩阵的张量
进一步开阔视野，不要局限于线性空间的自同态，把前面Lie群的例子拓展为两个线性映射， 
 作用于 
 ，
 作用于 
都是线性的：
以上(11)~(13)都可以类似推导。若 
 以及 
 ，那么作为可以用矩阵表示的线性映射有 
 及 
 ，其矩阵表示的张量就是矩阵张量积 
 。
我们准备从线性空间的张量过渡到模范畴上讨论。在线性代数中，取 
 ，
 ，矩阵乘法是相容的：
方矩阵环 
 对左右两个模起到的中介的作用，并且矩阵相乘后 
 不再是环 
 上的模，环的作用在矩阵乘法中被消去了——换句话说，直积 
 保留了全部信息，而 
 消去了线性算子环 
 而构成了某种商，不严格地说，以上矩阵乘法的过程实际上是在直积上商掉一个 
 相关的等价关系 
 ：
现在我们从矩阵的张量积来讨论。(15)中的矩阵乘法若改为张量积：
注意到 
 ，在直积中冗余的信息，在张量积中也可能冗余。(16)的商的过程，相当于：
这个商掉等价关系得道矩阵乘法的过程，就是张量的缩并。