精华内容
下载资源
问答
  • 两个矩阵的乘积是一个矩阵,它是由第一个矩阵的每一行乘以第二个矩阵的每一列得到的,如图 1 所示。图 1 矩阵乘法和内积运算为了使矩阵内积成为可能,左操作数(矩阵 A)的列数必须和右操作数(矩阵 B)的行数相同。如果...

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

    460e2a0babb0ef2462e1447e1719acb3.png

    图 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),这个方法涉及求解下面的等式:

    4ca54153b43032e8a52fae61b1a06980.png

    解出等式的系数 a 和 b:

    7adb3b6a1df6c898d51c373c937af2de.png

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

    41af97a51ce347736c0935faf912910d.png

    显然,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,等式就可以写为:

    f9c3a22f0ce408b0392354cbdf53f464.png

    现在 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 的右边显示了程序的输出,左边是回归直线和原始数据点的图形。

    2ff74ba96000e1f226e44476b78ec16b.png

    图 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中计算矩阵相乘、点乘(内积)、卷积的方法demo。输入数据均使用numpy生成随机多维数组。# coding:utf-8 import tensorflow as tf import numpy as np import time # 用numpy创建一个 10x5 矩阵 # 加...

    首先,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)))
    

    展开全文
  • C++ inner_product内积计算方法详解

    千次阅读 2018-12-28 14:34:40
    两个矩阵的乘积是一个矩阵,它是由第一个矩阵的每一行乘以第二个矩阵的每一列得到的,如图 1 所示。 图 1 矩阵乘法和内积运算 为了使矩阵内积成为可能,左操作数(矩阵 A)的列数必须和右操作数(矩阵 B)的行数...

    两个 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 的内积。例如:

    
     
    1. std::vector<int> v1(10);
    2. std::vector<int> v2(10);
    3. std::iota(std::begin(v1), std::end(v1), 2); // 2 3 4 5 6 7 8 9 10 11
    4. std::iota (std::begin(v2) , std::end(v2),3); // 3 4 5 6 7 8 9 10 11 12
    5. std::cout << std::inner_product(std::begin(v1), std::end(v1), std::begin(v2),0)<<std:rendl; // Output: 570

    因为两个 vector 的内积的标准定义,内积的初值为 0,但可以选择为对应元素的乘积 之和指定不同的初值。在使用 inner_product() 时,使用正确的类型很重要,如下所示:

    
     
    1. std::vector<double> data {0.5, 0.75, 0.85};
    2. auto resultl = std::inner_product(std::begin(data), std::end(data), std::begin(data),0);
    3. double result2 = std::inner_product(std:rbegin(data),std::end(data), std:: begin(data), 0);
    4. auto result3 = std::inner_product(std::begin(data), std::end(data), std:rbegin(data)r 0.0);
    5. 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() 算法对这些是非常有帮助的。

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

    
     
    1. // Least squares regression
    2. #include <numeric> // For accumulate(), inner_product()
    3. #include <vector> // For vector container
    4. #include <iostream> // For standard streams
    5. #include <iomanip> // For stream manipulators
    6. #include <fstream> // For file streams
    7. #include <iterator> // For iterators and begin() and end()
    8. #include <string> // For string class
    9. using std::string;
    10.  
    11. int main()
    12. {
    13. // File contains country_name renewables_per_person kwh_cost
    14. string file_in {"G:/Beginning_STL/renewables_vs_kwh_cost.txt"};
    15. std::ifstream in {file_in};
    16. if(!in) // Verify we have a file
    17. {
    18. std::cerr << file_in << " not open." << std::endl;
    19. exit(1);
    20. }
    21.  
    22. std::vector<double> x; // Renewables per head
    23. std::vector<double> y; // Corresponding cost for a kilowatt hour
    24.  
    25. // Read the file and show the data
    26. std::cout << " Country " << " Watts per Head " << " kwh cost(cents) " << std::endl;
    27. while(true)
    28. {
    29. string country;
    30. double renewables {};
    31. double kwh_cost {};
    32.  
    33. if((in >> country).eof()) break; // EOF read - we are done
    34. in >> renewables >> kwh_cost;
    35. x.push_back(renewables);
    36. y.push_back(kwh_cost);
    37. std::cout << std::left << std::setw(12) << country<< std::right<< std::fixed << std::setprecision(2) << std::setw(12) << renewables
    38. << std::setw(16) << kwh_cost << std::endl;
    39. }
    40.  
    41. auto n = x.size(); // Number of points
    42. auto sx = std::accumulate(std::begin(x), std::end(x), 0.0); // Sum of x values
    43. auto sy = std::accumulate(std::begin(y), std::end(y), 0.0); // Sum of y values
    44. auto mean_x = sx/n; // Mean of x values
    45. auto mean_y = sy/n; // Mean of y values
    46.  
    47. // Sum of x*y values and sum of x-squared
    48. auto sxy = std::inner_product(std::begin(x), std::end(x), std::begin(y), 0.0);
    49. auto sx_2 = std::inner_product(std::begin(x), std::end(x), std::begin(x), 0.0);
    50.  
    51. double a {}, b {}; // Line coefficients
    52. auto num = n*sxy - sx*sy; // Numerator for a
    53. auto denom = n*sx_2 - sx*sx; // Denominator for a
    54. a = num / denom;
    55. b = mean_y - a*mean_x;
    56. std::cout << std:: fixed << std::setprecision(3) << "\ny = "<< a << "*x + " << b << std::endl;
    57. }

    在 while 循环中读取了文件。只保存数值,每一个都完整记录了国家名称、人均新再生能源装机量的瓦特数,每千瓦时花费的成本则以美分的形式被写到标准输出流中。对于保存在 vector 容器中的两个值;x 记录的是每个国家人均的可再生容量,记录的是对应的千瓦时的成本。

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

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



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

    
     
    1. auto n = x.size(); // Number of points
    2. //Calculate mean values for x, y, xy, and x一squared
    3. auto mean_x = std::accumulate(std::begin(x), std::end(x), 0.0);
    4. auto mean_y = std::accumulate(std::begin(y), std::end(y), 0.0);
    5. auto mean_xy = std::inner_product(std::begin(x), std::end(x),std::begin (y), 0.0);
    6. auto mean_x2 = std::inner_product(std::begin(x), std::end(x), std::begin(x), 0.0);
    7. //Calculate coefficients
    8. auto a = (mean_xy - mean_x*mean_y)/(mean_x2-mean_x*mean_x);
    9. auto b = mean_y - a*mean_x;

    这里用更少的代码实现了相同的结果。图 2 的右边显示了程序的输出,左边是回归直线和原始数据点的图形。



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


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

    定义内积运算

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

    
     
    1. std::vector<int> v1(5);
    2. std::vector<int> v2(5);
    3. std::iota(std::begin(v1), std::end(v1), 2); // 2 3 4 5 6
    4. std::iota(std::begin(v2), std::end(v2), 3); // 3 4 5 6 7
    5. 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。

    展开全文
  • 下面我们探讨矩阵张量积所蕴含意义。...Hermite内积的张量表示回顾一个过去多次讨论例子,详细推导见:MP32:张量专题(1):SO(2)和平面向量张量 MP86:辛(symplectic)起源(1):三角函数线性性与Hermit...

    8b5f772107da23bbaba3f14238cfdf02.png

    下面我们探讨矩阵张量积所蕴含的意义。将域

    上的
    方矩阵(phalanx)的集合记为
    ,矩阵张量积的计算如下:

    447ae9e05e84055fb90bb012ccee9d11.png
    [余扬政1998] 物理学中的几何方法

    后面将看到,矩阵的张量积可以不限于方矩阵。

    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)的商的过程,相当于:

    这个商掉等价关系得道矩阵乘法的过程,就是张量的缩并。

    展开全文
  • 该算法通过代数变换,把对原高维矩阵的非负分解转换成非负的低维矩阵的非负分解,其求解过程只需要对一个阶数等于样本数的对角矩阵进行非负矩阵分解,同时提取某样本特征时只需要计算该样本与所有训练样本的内积。...
  • 矩阵自身(行)向量之间距离矩阵计算2.1 第方法:简单使用两重循环2.2 第二种方法矩阵內积双重循环2.3 第三种方法:避免循环内点积运算2.4 第四种方法:避免循环2.5 第五种方法:利用`scipy`求距离矩阵...
  • 针对已有扩频码估计方法计算复杂度高问题,提出种基于平均内积和相关判决函数扩频码估计方法.首先采用窗长为伪码周期滑动窗函数将信号划分为不重叠数据段,以各分段数据为行向量依次排列构造数据矩阵,并根据...
  • 写过篇,numpy中dot()、outer()、multiply()以及matmul()区别,介绍了numpy中、外、转置、矩阵-向量乘法、矩阵-矩阵乘法等计算方法。在Pytorch中这些矩阵运算是很常见,几乎存在于每模型中。那么在...
  • 在使用Numpy或者TensorFlowtensordot方法进行矩阵相乘时候,axes是一个重要参数,它可以定义两个矩阵互乘时候是使用内积、外积、或是其他方法。不管Numpy还是TensorFlow,它们使用tensordotaxes参数的方法...
  • 矩阵按照行划分,之后,再每个线程都用整个向量跟这个块做内积。之后,传回来一个数值。 这里的方法二, 将矩阵按照列进行划分。然后将列向量传递给所有线程,之后,再传对应向量对应元素,给这个线程。...
  • 最近在学习pytorch,过程中遇到一些问题,这里权当笔记记录下来,同时也供大家参考。 下面简单回顾一下矩阵中的乘法:...它要求前一个矩阵的行数等于后一个矩阵的列数,其计算方法是计算结果的每一行元素为前一个...
  • 数量,点

    2012-03-07 11:54:09
    在数学中,数量积(也称为标量积、点积、点乘)是接受在实数R上两个矢量并返回一个实数值标量二元运算。它是欧几里得空间标准内积。   计算方法 两个矢量a = [a1, a2,…, an]和b = [b1, b2,…, bn...
  • np.dot(,) 计算矩阵内积。 transpose() swapaxes()方法 通用函数:快速元素级数组函数 通用函数即ufunc是一种对ndarray中数据执行元素级运算函数。你可以将其看做简单函数(接受一个或多个标量值,并产生一个...
  • 每个数字都来自于一个特定滤波器在特定位置卷积,因此每个数字代表一个特征强度,而Gram计算的实际上是两两特征之间相关性,哪两个特征是同时出现,哪两个是此消彼长等等,同时,Gram对角线元素,还体现...
  • 第三节 乘法和逆矩阵

    2020-12-23 18:08:31
    矩阵乘法 在之前章节已经简单介绍了矩阵...方法一,行列内积 一般性法则,基本思想是分别计算目标矩阵节点值 [a11a12...a1na21a22...a2n............ai1ai2...ain............am1am2...amn]×[b11b12...b1j..
  • 这些理论中最简单的局部共形算子混合矩阵的条目(4D中的双标量模型和3D中的三标量模型)在任何给定的循环顺序下都由单个Feynman图给出。 相关图原则上可以通过可积分性方法(量子谱曲线或ABA)计算,最多可以...
  • 1.设计内容实现一个特殊的计算器,可以实现复数、有理数、矩阵和集合的特殊计算。程序可以实现复数、有理数的加、减、乘、除,可以实现矩阵的加法、减法和乘法运算,也可以实现集合的求交集、并集、子集的运算。2....
  • 一:基本概念 ...(一)点(dot product) ...两个运算的矩阵需要满足矩阵乘法的规则,即需要前一个矩阵的列与后一个矩阵的行相匹配。 总之:上面的两个概念都是针对向量或者矩阵的运算,需要和标量的计算区分开来。 二
  • 最近(2018.05)重新学习了一下线性代数,读完了《程序猿数学 3 线性代数》,为深刻理解内容,打算实现一个矩阵库,并写 Python 模块。计划涉及如下部分:向量内积矩阵乘法LU 分解线性方程组求解行列式计算逆矩阵实...
  • 进行矩阵运算时,经常要用数组转置,比如计算矩阵内积X^T X.这时就需要利用数组转置,如下: 2.轴对换之transpose 对于高维数组,可以使用轴对换来对多个维度进行变换。 这里创建了一个三维数组,各维度大小...
  • 1.首先数组转置(T)创建二维数组data如下:进行矩阵运算时,经常要用数组转置,比如计算矩阵内积X^T X.这时就需要利用数组转置,如下:2.轴对换之transpose对于高维数组,可以使用轴对换来对多维度进行变换。这里...
  • 范例1-8 查找矩阵的马鞍点 19 ∷相关函数:Get_Saddle函数 1.1.9 对角矩阵建立 21 范例1-9 对角矩阵建立 21 ∷相关函数:Store函数 1.1.10 三对角矩阵的建立 22 范例1-10 三对角矩阵的建立 22 ∷相关函数:...
  • 降维方法总结

    千次阅读 2018-06-10 13:58:13
    降维方法总结对降维效果的评价:比较降维前后...1)通过距离不变的原理,推导出由高维空间距离矩阵D计算低维空间样本的内积矩阵B,2)对B做特征值分解3)根据特征值分解的结果,计算出样本的低维空间坐标——可以理...
  • numpy中ndarray很适合数组运算 transpose是用来转置的一个函数,很容易让人困惑,其实它是对矩阵... 您可能感兴趣文章:对numpy中数组转置求解以及向量内积计算方法Numpy数组转置两种实现方法详解Numpy数组转置
  • 1.1 一个例程 1.2 类型与声明 1.3 基本类型 1.3.1 整数类型 1.3.2 字符类型 1.3.3 浮点类型 1.3.4 布尔类型 1.3.5 void类型 1.4 数值极限 1.5 标识符和关键词 1.5.1 标识符 1.5.2 ...
  • 该系统使用ARM处理器作为总控制器,控制各个子模块调用和数据传输,FPGA内通过对矩阵向量内积算法进行优化提高LSTM网络内部数据运算速度,并且采用多项式近似的方法降低了激活函数所占用资源。实验结果表明,...
  • 原始形式和对偶形式是从两个方面去计算梯度下降问题,两种方法找误分点个数是一样,区别在于,找到一个误分点时两者接下来的计算方法:(N为训练集大小,n为特征数量) (1)对偶形式:扫一遍N,计算每条数据...
  • 随机数产生 3.1 产生0到1之间均匀分布的一个随机数 3.2 产生0到1之间均匀分布随机数序列 3.3 产生任意区间均匀分布的一个随机整数 3.4 产生任意区间均匀分布随机整数序列 3.5 产生任意均值...

空空如也

空空如也

1 2 3 4
收藏数 70
精华内容 28
关键字:

一个矩阵的内积计算方法