devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

转置算子(transpose)的一种实现_transpose算子

作者：知新_RL | 2024-02-27 15:48:45

赞

踩

transpose算子

transpose算子也叫做permute算子，根据白嫖有道英汉大词典的结果，他俩都是转置，改变排列顺序的意思。

算法逻辑是：

  1. 通过当前输出的一维偏移量(offset)计算输入矩阵对应的高维索引

  2. 然后根据参数pos重新排列输出索引，进而得到输出索引。

  3. 将输出索引转换成输入偏移量.

  4. 最后进行数据移动，整个过程的示意图如下.

上代码，pos[]数组表示将输入矩阵的pos[i]维，映射到输出矩阵的第i维。

  1. /*
  2.  * ===========================================================================================
  3.  *
  4.  *       Filename:  transpose.c
  5.  *
  6.  *    Description:  transpose operator impl.
  7.  *
  8.  *        Version:   
  9.  *         Create:  2021-11-07 14:08:50
  10.  *       Revision:  none
  11.  *       Compiler:  GCC:version 7.2.1 20170904 (release),ARM/embedded-7-branch revision 255204
  12.  *
  13.  *         Author:  
  14.  *   Organization:  
  15.   Last Modified : 2021-11-07 20:22:56
  16.  *
  17.  * ===========================================================================================
  18.  */
  19. #include <stdio.h>
  20. #include <stdlib.h>
  21.  
  22. #define DBG(fmt, ...)   do{ printf("%s line %d, "fmt"\n", __func__, __LINE__, ##__VA_ARGS__); } while(0)
  23.  
  24. void transpose_matrix(float *matrix_A, float **matrix_B, int *shape_A, int dims_A, int *pos)
  25. {
  26.     float *B;
  27.     int element_count;
  28.     int i;
  29.  
  30.     element_count = 1;
  31.     for(i = 0; i < dims_A; i ++)
  32.     {
  33.         element_count *= shape_A[i];
  34.     }
  35.  
  36.     B = (float *)malloc(element_count * sizeof(float));
  37.     if(B == NULL)
  38.     {
  39.         DBG("malloc buffer for B failure.");
  40.         return;
  41.     }
  42.     
  43.     int* shape_B = (int *)malloc(sizeof(int) * dims_A);
  44.     if(shape_B == NULL)
  45.     {
  46.         DBG("malloc shape buffer for B failure.");
  47.         return;
  48.     }
  49.  
  50.     for(int i = 0; i < dims_A; i++)
  51.     {
  52.         shape_B[i] = shape_A[pos[i]];
  53.     }
  54.  
  55.     int* indexA = (int*)malloc(sizeof(int) * dims_A);
  56.     if(indexA == NULL)
  57.     {
  58.         DBG("failure to malloc matrix A index.");
  59.         return;
  60.     }
  61.  
  62.     int* indexB = (int*)malloc(sizeof(int) * dims_A);
  63.     if(indexB == NULL)
  64.     {
  65.         DBG("failure to malloc matrix B index.");
  66.         return;
  67.     }
  68.  
  69.     for(int src = 0; src < element_count; src++)
  70.     {
  71.         int temp = src;
  72.         for(i = dims_A-1; i >= 0; i--)
  73.         {
  74.             indexA[i] = temp % shape_A[i];
  75.             temp = temp / shape_A[i];
  76.         }
  77.  
  78.         for(i = 0; i < dims_A; i++)
  79.         {
  80.             indexB[i] = indexA[pos[i]];
  81.         }
  82.  
  83.         int dst = 0;
  84.         temp = 1;
  85.         for(i = dims_A - 1; i >= 0; i--)
  86.         {
  87.             dst = dst + indexB[i] * temp;
  88.             temp = temp * shape_B[i];
  89.         }
  90.  
  91.         B[dst] = matrix_A[src];
  92.     }
  93.  
  94.     free(indexA);
  95.     free(indexB);
  96.  
  97.     indexA = indexB = NULL;
  98.  
  99.     *matrix_B=B;
  100.     return;
  101. }
  102.  
  103. void print_tensor(const float* A, int* shape, int dim)
  104. {                     
  105.     int elem = 1;     
  106.     for(int i = 0; i < dim; i++)
  107.     {                 
  108.         elem = elem * shape[i];
  109.     }                 
  110.  
  111.     printf("Array size: %d\n", elem);
  112.     for(int i = 0; i < elem; i++)
  113.     {                 
  114.         printf( "%f ", A[i] );
  115.         int split = 1;         
  116.         for(int j = dim-1; j > 0; j--)
  117.         {                      
  118.             split = split * shape[j];
  119.             if( (i+1) % split == 0)
  120.             {
  121.                 printf("\n");
  122.             }         
  123.         }             
  124.     }                 
  125. } 
  126.  
  127. int main(void)
  128. {
  129.     float* B;
  130.     float A[24] =
  131.     { 
  132.         1,  2,  3,  4,  
  133.         5,  6,  7,  8,  
  134.         9, 10, 11, 12, 
  135.        
  136.         13, 14, 15, 16, 
  137.         17, 18, 19, 20, 
  138.         21, 22, 23, 24
  139.     };  
  140.  
  141.     int shapeA[] = {2, 3, 4}; 
  142.     int dimA = 3;
  143.  
  144.     print_tensor(A, shapeA, dimA);
  145.  
  146.     // Transpose
  147.     int perm[] = { 2, 0, 1}; 
  148.     transpose_matrix(A, &B, shapeA, dimA, perm);
  149.  
  150.     // Print B
  151.     int shapeB[] = {4, 2, 3}; 
  152.     int dimB = 3;
  153.     print_tensor(B, shapeB, dimB);
  154.  
  155.     int shapeM[] = {2, 2, 2, 3}; 
  156.     int dimM = 4;
  157.  
  158.     print_tensor(A, shapeM, dimM);
  159.  
  160.     // Transpose
  161.     int permM[] = {3, 0, 1, 2}; 
  162.     transpose_matrix(A, &B, shapeM, dimM, permM);
  163.  
  164.     // Print B
  165.     int shapeO[] = {3, 2, 2, 2}; 
  166.     int dimO = 4;
  167.     print_tensor(B, shapeO, dimO); 
  168.  
  169.     // Free memory
  170.     free(B);
  171.  
  172.     return 0;
  173. }

运行结果

  1. (base) caozilong@caozilong-Vostro-3268:~/Workspace/transpose$ ./a.out 
  2. Array size: 24
  3. 1.000000 2.000000 3.000000 4.000000 
  4. 5.000000 6.000000 7.000000 8.000000 
  5. 9.000000 10.000000 11.000000 12.000000 
  6.  
  7. 13.000000 14.000000 15.000000 16.000000 
  8. 17.000000 18.000000 19.000000 20.000000 
  9. 21.000000 22.000000 23.000000 24.000000 
  10.  
  11. Array size: 24
  12. 1.000000 5.000000 9.000000 
  13. 13.000000 17.000000 21.000000 
  14.  
  15. 2.000000 6.000000 10.000000 
  16. 14.000000 18.000000 22.000000 
  17.  
  18. 3.000000 7.000000 11.000000 
  19. 15.000000 19.000000 23.000000 
  20.  
  21. 4.000000 8.000000 12.000000 
  22. 16.000000 20.000000 24.000000 
  23.  
  24. Array size: 24
  25. 1.000000 2.000000 3.000000 
  26. 4.000000 5.000000 6.000000 
  27.  
  28. 7.000000 8.000000 9.000000 
  29. 10.000000 11.000000 12.000000 
  30.  
  31.  
  32. 13.000000 14.000000 15.000000 
  33. 16.000000 17.000000 18.000000 
  34.  
  35. 19.000000 20.000000 21.000000 
  36. 22.000000 23.000000 24.000000 
  37.  
  38.  
  39. Array size: 24
  40. 1.000000 4.000000 
  41. 7.000000 10.000000 
  42.  
  43. 13.000000 16.000000 
  44. 19.000000 22.000000 
  45.  
  46.  
  47. 2.000000 5.000000 
  48. 8.000000 11.000000 
  49.  
  50. 14.000000 17.000000 
  51. 20.000000 23.000000 
  52.  
  53.  
  54. 3.000000 6.000000 
  55. 9.000000 12.000000 
  56.  
  57. 15.000000 18.000000 
  58. 21.000000 24.000000 
  59.  
  60.  
  61. (base) caozilong@caozilong-Vostro-3268:~/Workspace/transpose$

通过这个程序，发现一个很有意思的规律，大概描述如下，在N维空间下，<=N的tensor做转置，不需要对tensor做结构上的改变，只需要转换观察角度即可,因为空间维度容的下数据向各个方向的扩展.

以三维空间为例，对于二维矩阵的转置操作，我们只需要分别从列向量和行向量的方向上观察即可，不需要做矩阵做调整。

对于三维的物体也是一样，我们以魔方为例在说明：

 不管魔方是几阶的，它都是三维的，都可以用一个三维的数组来表示。A[M][N][P],对于，M，N，P全排列中的任何一个，我们都可以通过切换观察视角来理解它的转置操作，而不需要对它做结构上的调整。

但是，当高维矩阵在内存中存储时，由于内存模型是线性表模型，它是一维的，一维的空间容不下多个维度，所以必须要扁平化 “降维” 成1维。对于N维tensor来说，这个降维排布方式有N！种方式。对应了高维空间中的几种观察视角的变化切换。

那么四维空间中魔方该如和表示置换操作呢？我们生活的空间是三维的，对于四维空间，我们缺乏像对三维空间那样直观的认识，更别说四维的魔方了。它超出了我们的认知范围，但是从数学的角度看，我们可以通过将第四维看成是是在某个三维方向上的拓展或者对某个维度的复用，还是以魔方为例，我们可以通过将组成魔方的每个小方块在划分维度，比如1维，2维。。。等等，想象一个魔方中的魔方，每个小方块还是一个魔方，那就是3*3*3*（3*3*3）六个维度，通过这种方式，我们可以定义任意维度的魔方，构造上有点像俄罗斯套娃。

但是，理解这种构造魔方的转置还有一个局限，就是它的维度已经超过了所在空间的维度，所有，有些维度会复用，造成“冲突”，还是以魔方为例，俄罗斯套娃方式构造的魔方，每个小方框其实都是对三维空间的复用，它不存在真正的它所在的高维对应的维度，所以，如果要完成置换，可能需要对魔方的构造进行调整，而不单单是仅仅是进行视角的变化。

这是由矩阵转置联想到的一点粗浅的理解，可能有错误，但这并不重要，每个人的认识都是在不断的纠正错误中前进的，权且记录下来，以便日后思考，更正吧。 

总结：

代码中，shape和数组形式定义的维度序关系如下:

imple by myself:

  1. #include <stdio.h>
  2.  
  3. int main(void)
  4. {
  5.     static int abc = 0;
  6.  
  7. 	int a[6][6][3];
  8. 	int b[3][6][6];
  9.  
  10. 	int i,j,k;
  11.  
  12. 	for(i = 0; i < 6; i ++)
  13. 	{
  14. 		for(j = 0; j < 6; j ++)
  15. 		{
  16. 			for(k = 0; k < 3; k ++)
  17. 				a[i][j][k] =  abc ++;
  18. 		}
  19. 	}
  20.  
  21. 	for(i = 0; i < 6; i ++)
  22. 	{
  23. 		for(j = 0; j < 6; j ++)
  24. 		{
  25. 			for(k = 0; k < 3; k ++)
  26. 				printf("%3d ", a[i][j][k]);
  27.  
  28. 			printf("\n");
  29. 		}
  30. 		printf("\n");
  31. 		printf("\n");
  32. 	}
  33.  
  34. 	printf("========================================\n");
  35.  
  36. 	for(i = 0; i < 3; i ++)
  37. 	{
  38. 		for(j = 0; j < 6; j ++)
  39. 		{
  40. 			for(k = 0; k < 6; k ++)
  41. 				b[i][j][k] =  a[j][k][i];
  42. 		}
  43. 	}
  44.  
  45. 	for(i = 0; i < 3; i ++)
  46. 	{
  47. 		for(j = 0; j < 6; j ++)
  48. 		{
  49. 			for(k = 0; k < 6; k ++)
  50. 				printf("%3d ", b[i][j][k]);
  51.  
  52. 			printf("\n");
  53. 		}
  54. 		printf("\n");
  55. 		printf("\n");
  56. 	}
  57.  
  58. 	return 0;
  59. }

RGB图像transform的一种方式。

RGB图像的三个维度是长，宽，和 色彩（可以理解为高），长宽转置没有意义(也不能完全说没有意义，内存是一维的，存储方向肯定发生了变化），所以可以将长宽看成一个维度，所以，RGBRGBRGB。。。。排列方式和RRRRR。。。GGGGG。。。BBBBB两种方式的区别在于颜色和【XY】的转置。

结束！

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/154198
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号