算法这东西，有时候真不是靠死记硬背就能学会的。

你想想看，那会儿做图论时，遇到邻接矩阵 A，还得手算 $A^n$ 的中间项，再乘进 $v_0$ 里，那感觉跟算物理题一样，全是算。可目前引入了图卷积网络、Transformer 这种大模型，它们处理长序列的数据简直是把“矩阵乘法”干到了天上。

那会儿我们用的层 1 到层 80 都是 $2 times 2$ 的矩阵，全做卷积，目前呢？模型越来越智能，有些步骤就连懒得做矩阵运算，直接在输入里加个 Mask 要么加个 `x` scalar，这事儿啊，就是让计算变得更“智慧”了。

这就好比那会儿让你抄答案，目前要求你直接写出解题思路，就连你自己得去推导公式，反正都得靠脑子，脑子背不动了。 这背后的逻辑实际上挺好办，就是把那些繁琐的数学操作给“糊”掉。

比如我们在深度学习中那些 $W in mathbb{R}^{d times k}$ 的权重矩阵，那会儿是老老实实做矩阵乘法，$W cdot X$，结局出来的维度不对，就得根据公式 $Y = W cdot X + b$ 重新调整形状，这时候脑子得转悠半天，还要算加法减法的步骤。目前呢？模型天生就怕这些复杂的维度变换。

既然不用做矩阵乘法，那输入就是个序列，输出就是个序列，中间不经过矩阵运算，直接转个 Type 就完事了。就连更绝的是，有些模型输入数据本身就已经是 $2 times 1$ 要么 $1 times 2$ 的形状了，不需求转成 $(2, 2)$ 的矩阵，直接做 `2 scalar` 就行。

这就像那会儿开车要换挡、踩离合、挂挡，目前直接一脚油门下去，车自己就走了，反正换挡那是为了配合后面的换挡，为了配合前面的换挡，目前连换挡都不用，直接跑就行。 再往深了说，这种“偷懒”背后实际上是计算图优化和自动微分机制在悄悄起功能。

那会儿你写代码，每一行都要寻思维度升降，编译器再帮你优化，有时候还得手动改一下数据类型。目前呢？模型本身就在教编译器如何干。当你说了一句“把 $X$ 转成 $(2, 1)$"的时候，编译器知道，不用转了，直接转成 $2 times scalar$ 就能够了，出于它内置的逻辑就是赞成这种非矩阵形式的输入。

这就好比那会儿做菜得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手（编译器）也不管你是切菜还是炒菜，反正只要火够，菜就熟了。

这种“甭管啥形状都能干”的本事，确实是模型变强的关键所在。 举个具体的例子，假设我们要处理一段长文本，涉及到的词频统计要么情感分析。

那会儿可能需求读图，把邻接矩阵读出来，然后做 $A^2$ 要么 $A^3$ 的幂运算。别看目前有些图模型就连懒得做这些矩阵幂运算，直接通过并行的图卷积层把节点特征融合在一起，输入数据直接就是序列。就连更了得的是，有些模型在处理特定任务时，输入数据就直接是 $2 times 2$ 的矩阵，彻底不需求转成 $(2, 2)$，直接做 $2 times scalar$ 就能搞定。

这简直是把数学推导压缩到了极致，那会儿你得为了训练模型去推导 $W cdot X$ 的维度公式，目前呢？不需求，只要输入是 $2 times 1$ 要么 $1 times 2$，要么输入本身就是 $2 times 2$ 这种特定形状，直接转 Type 就对了。

这就好比那会儿做数学题，老师让你把 $3 times 1$ 的矩阵转成 $1 times 3$ 再乘，还得让你推导 $A cdot A^T$ 的公式，目前呢？给你 $3 times 1$ 的矩阵，你直接转成 $1 times 3$ 再乘，要么给你 $1 times 1$ 的矩阵，你直接转 Type 就行，反正目前不管你如何转，结局都是对的。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程里。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿让你写一段程序，你要把 $3 times 3$ 的矩阵转成 $3 times 1$ 再乘，你得写出这行代码，目前呢？你直接说“把 $3 times 3$ 的矩阵转成 $3 times 1$"，程序自己就知道如何干，你别想那些复杂的维度变换逻辑了。更绝的是，有些模型就连懒得做矩阵运算，直接输入就是个序列，输出就是个序列，中间不经过矩阵运算，直接转个 Type 就完事了。

这简直是把数学推导压缩到了极致，那会儿你得为了训练模型去推导 $W cdot X$ 的维度公式，目前呢？不需求，只要输入是 $2 times 1$ 要么 $1 times 2$，要么输入本身就是 $2 times 2$ 这种特定形状，直接转 Type 就对了。 再聊聊数据本身，那会儿做实验时，时常得手动调整数据格式，比如把字符串转成 int，把 int 转成 float，这时候脑子得像在转圈圈。目前呢？模型本身就在教数据如何转。当你说了一句“把字符串转成 int"的时候，模型知道，不用转了，直接转成 int 就能够了，出于它内置的逻辑就是赞成这种非矩阵形式的输入。

这就好比那会儿做菜，你得自己拍板是用切好的菜还是生肉，目前呢？你直接把菜扔进锅里，厨师（编译器）不管你是切菜还是炒肉，反正只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。

这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程里。 还有啊，有时候就连在推理阶段，模型都能够自己拍板要不要做矩阵运算，也能够直接转成非矩阵形式。

这就像那会儿写代码，你务必写上每一行来保证维度对，目前呢？只要结局对就行，中间如何凑都能够。

比如你要算 $X cdot X$ 的平方，那会儿得手动算出 $(X cdot X)^2$ 的维度，目前呢？直接说“把 $X cdot X$ 的平方转成 Type"，反正目前不管你如何转，结局都是对的。

这就像那会儿开车要换挡、踩离合、挂挡，目前直接一脚油门下去，车自己就走了，反正换挡那是为了配合后面的换挡，为了配合前面的换挡，目前连换挡都不用，直接跑就行。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程里。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿做菜，你得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。

这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程里。 最终说点实在的，这种变化不只是是技术层面的，更是一种思维模式的转变。

那会儿写代码，每一行都要寻思维度升降，编译器再帮你优化，有时候还得手动改一下数据类型。目前呢？模型本身就在教编译器如何干。当你说了一句“把 $X$ 转成 $(2, 1)$"的时候，编译器知道，不用转了，直接转成 $2 times scalar$ 就能够了，出于它内置的逻辑就是赞成这种非矩阵形式的输入。

这就好比那会儿让你抄答案，目前要求你直接写出解题思路，就连你自己得去推导公式，反正都得靠脑子，脑子背不动了。 实际上啊，哪怕是在一个最好办的例子里，比如你要把 $3 times 3$ 的矩阵转成 $3 times 1$ 再乘，那会儿你得写出这行代码，目前呢？你直接说“把 $3 times 3$ 的矩阵转成 $3 times 1$"，程序自己就知道如何干，你别想那些复杂的维度变换逻辑了。更绝的是，有些模型就连懒得做矩阵运算，直接输入就是个序列，输出就是个序列，中间不经过矩阵运算，直接转个 Type 就完事了。

这简直是把数学推导压缩到了极致，那会儿你得为了训练模型去推导 $W cdot X$ 的维度公式，目前呢？不需求，只要输入是 $2 times 1$ 要么 $1 times 2$，要么输入本身就是 $2 times 2$ 这种特定形状，直接转 Type 就对了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程里。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿开车要换挡、踩离合、挂挡，目前直接一脚油门下去，车自己就走了，反正换挡那是为了配合后面的换挡，为了配合前面的换挡，目前连换挡都不用，直接跑就行。 再说点别的，有时候就连在推理阶段，模型都能够自己拍板要不要做矩阵运算，也能够直接转成非矩阵形式。

这就像那会儿写代码，你务必写上每一行来保证维度对，目前呢？只要结局对就行，中间如何凑都能够。

比如你要算 $X cdot X$ 的平方，那会儿得手动算出 $(X cdot X)^2$ 的维度，目前呢？直接说“把 $X cdot X$ 的平方转成 Type"，反正目前不管你如何转，结局都是对的。

这就像那会儿做菜，你得自己拍板是用切好的菜还是生肉，目前呢？你直接把菜扔进锅里，厨师（编译器）不管你是切菜还是炒肉，反正只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程里。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿做菜，你得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 最终说点实在的，这种变化不只是是技术层面的，更是一种思维模式的转变。

那会儿写代码，每一行都要寻思维度升降，编译器再帮你优化，有时候还得手动改一下数据类型。目前呢？模型本身就在教编译器如何干。当你说了一句“把 $X$ 转成 $(2, 1)$"的时候，编译器知道，不用转了，直接转成 $2 times scalar$ 就能够了，出于它内置的逻辑就是赞成这种非矩阵形式的输入。

这就好比那会儿让你抄答案，目前要求你直接写出解题思路，就连你自己得去推导公式，反正都得靠脑子，脑子背不动了。 实际上啊，哪怕是在一个最好办的例子里，比如你要把 $3 times 3$ 的矩阵转成 $3 times 1$ 再乘，那会儿你得写出这行代码，目前呢？你直接说“把 $3 times 3$ 的矩阵转成 $3 times 1$"，程序自己就知道如何干，你别想那些复杂的维度变换逻辑了。更绝的是，有些模型就连懒得做矩阵运算，直接输入就是个序列，输出就是个序列，中间不经过矩阵运算，直接转个 Type 就完事了。

这简直是把数学推导压缩到了极致，那会儿你得为了训练模型去推导 $W cdot X$ 的维度公式，目前呢？不需求，只要输入是 $2 times 1$ 要么 $1 times 2$，要么输入本身就是 $2 times 2$ 这种特定形状，直接转 Type 就对了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程里。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿开车要换挡、踩离合、挂挡，目前直接一脚油门下去，车自己就走了，反正换挡那是为了配合后面的换挡，为了配合前面的换挡，目前连换挡都不用，直接跑就行。 再说点别的，有时候就连在推理阶段，模型都能够自己拍板要不要做矩阵运算，也能够直接转成非矩阵形式。

这就像那会儿写代码，你务必写上每一行来保证维度对，目前呢？只要结局对就行，中间如何凑都能够。

比如你要算 $X cdot X$ 的平方，那会儿得手动算出 $(X cdot X)^2$ 的维度，目前呢？直接说“把 $X cdot X$ 的平方转成 Type"，反正目前不管你如何转，结局都是对的。

这就像那会儿做菜，你得自己拍板是用切好的菜还是生肉，目前呢？你直接把菜扔进锅里，厨师（编译器）不管你是切菜还是炒肉，反正只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程里。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿做菜，你得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 最终说点实在的，这种变化不只是是技术层面的，更是一种思维模式的转变。

那会儿写代码，每一行都要寻思维度升降，编译器再帮你优化，有时候还得手动改一下数据类型。目前呢？模型本身就在教编译器如何干。当你说了一句“把 $X$ 转成 $(2, 1)$"的时候，编译器知道，不用转了，直接转成 $2 times scalar$ 就能够了，出于它内置的逻辑就是赞成这种非矩阵形式的输入。

这就好比那会儿让你抄答案，目前要求你直接写出解题思路，就连你自己得去推导公式，反正都得靠脑子，脑子背不动了。 实际上啊，哪怕是在一个最好办的例子里，比如你要把 $3 times 3$ 的矩阵转成 $3 times 1$ 再乘，那会儿你得写出这行代码，目前呢？你直接说“把 $3 times 3$ 的矩阵转成 $3 times 1$"，程序自己就知道如何干，你别想那些复杂的维度变换逻辑了。更绝的是，有些模型就连懒得做矩阵运算，直接输入就是个序列，输出就是个序列，中间不经过矩阵运算，直接转个 Type 就完事了。

这简直是把数学推导压缩到了极致，那会儿你得为了训练模型去推导 $W cdot X$ 的维度公式，目前呢？不需求，只要输入是 $2 times 1$ 要么 $1 times 2$，要么输入本身就是 $2 times 2$ 这种特定形状，直接转 Type 就对了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程中。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿做菜，你得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。

这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程中。 有时候就连在推理阶段，模型都能够自己拍板要不要做矩阵运算，也能够直接转成非矩阵形式。

这就像那会儿写代码，你务必写上每一行来保证维度对，目前呢？只要结局对就行，中间如何凑都能够。

比如你要算 $X cdot X$ 的平方，那会儿得手动算出 $(X cdot X)^2$ 的维度，目前呢？直接说“把 $X cdot X$ 的平方转成 Type"，反正目前不管你如何转，结局都是对的。

这就像那会儿做菜，你得自己拍板是用切好的菜还是生肉，目前呢？你直接把菜扔进锅里，厨师（编译器）不管你是切菜还是炒肉，反正只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程中。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿做菜，你得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 最终说点实在的，这种变化不只是是技术层面的，更是一种思维模式的转变。

那会儿写代码，每一行都要寻思维度升降，编译器再帮你优化，有时候还得手动改一下数据类型。目前呢？模型本身就在教编译器如何干。当你说了一句“把 $X$ 转成 $(2, 1)$"的时候，编译器知道，不用转了，直接转成 $2 times scalar$ 就能够了，出于它内置的逻辑就是赞成这种非矩阵形式的输入。

这就好比那会儿让你抄答案，目前要求你直接写出解题思路，就连你自己得去推导公式，反正都得靠脑子，脑子背不动了。 实际上啊，哪怕是在一个最好办的例子里，比如你要把 $3 times 3$ 的矩阵转成 $3 times 1$ 再乘，那会儿你得写出这行代码，目前呢？你直接说“把 $3 times 3$ 的矩阵转成 $3 times 1$"，程序自己就知道如何干，你别想那些复杂的维度变换逻辑了。更绝的是，有些模型就连懒得做矩阵运算，直接输入就是个序列，输出就是个序列，中间不经过矩阵运算，直接转个 Type 就完事了。

这简直是把数学推导压缩到了极致，那会儿你得为了训练模型去推导 $W cdot X$ 的维度公式，目前呢？不需求，只要输入是 $2 times 1$ 要么 $1 times 2$，要么输入本身就是 $2 times 2$ 这种特定形状，直接转 Type 就对了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程中。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿做菜，你得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 有时候就连在推理阶段，模型都能够自己拍板要不要做矩阵运算，也能够直接转成非矩阵形式。

这就像那会儿写代码，你务必写上每一行来保证维度对，目前呢？只要结局对就行，中间如何凑都能够。

比如你要算 $X cdot X$ 的平方，那会儿得手动算出 $(X cdot X)^2$ 的维度，目前呢？直接说“把 $X cdot X$ 的平方转成 Type"，反正目前不管你如何转，结局都是对的。

这就像那会儿做菜，你得自己拍板是用切好的菜还是生肉，目前呢？你直接把菜扔进锅里，厨师（编译器）不管你是切菜还是炒肉，反正只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程中。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿做菜，你得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 最终说点实在的，这种变化不只是是技术层面的，更是一种思维模式的转变。

那会儿写代码，每一行都要寻思维度升降，编译器再帮你优化，有时候还得手动改一下数据类型。目前呢？模型本身就在教编译器如何干。当你说了一句“把 $X$ 转成 $(2, 1)$"的时候，编译器知道，不用转了，直接转成 $2 times scalar$ 就能够了，出于它内置的逻辑就是赞成这种非矩阵形式的输入。

这就好比那会儿让你抄答案，目前要求你直接写出解题思路，就连你自己得去推导公式，反正都得靠脑子，脑子背不动了。 实际上啊，哪怕是在一个最好办的例子里，比如你要把 $3 times 3$ 的矩阵转成 $3 times 1$ 再乘，那会儿你得写出这行代码，目前呢？你直接说“把 $3 times 3$ 的矩阵转成 $3 times 1$"，程序自己就知道如何干，你别想那些复杂的维度变换逻辑了。更绝的是，有些模型就连懒得做矩阵运算，直接输入就是个序列，输出就是个序列，中间不经过矩阵运算，直接转个 Type 就完事了。

这简直是把数学推导压缩到了极致，那会儿你得为了训练模型去推导 $W cdot X$ 的维度公式，目前呢？不需求，只要输入是 $2 times 1$ 要么 $1 times 2$，要么输入本身就是 $2 times 2$ 这种特定形状，直接转 Type 就对了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程中。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿做菜，你得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 有时候就连在推理阶段，模型都能够自己拍板要不要做矩阵运算，也能够直接转成非矩阵形式。

这就像那会儿写代码，你务必写上每一行来保证维度对，目前呢？只要结局对就行，中间如何凑都能够。

比如你要算 $X cdot X$ 的平方，那会儿得手动算出 $(X cdot X)^2$ 的维度，目前呢？直接说“把 $X cdot X$ 的平方转成 Type"，反正目前不管你如何转，结局都是对的。

这就像那会儿做菜，你得自己拍板是用切好的菜还是生肉，目前呢？你直接把菜扔进锅里，厨师（编译器）不管你是切菜还是炒肉，反正只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程中。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿做菜，你得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 最终说点实在的，这种变化不只是是技术层面的，更是一种思维模式的转变。

那会儿写代码，每一行都要寻思维度升降，编译器再帮你优化，有时候还得手动改一下数据类型。目前呢？模型本身就在教编译器如何干。当你说了一句“把 $X$ 转成 $(2, 1)$"的时候，编译器知道，不用转了，直接转成 $2 times scalar$ 就能够了，出于它内置的逻辑就是赞成这种非矩阵形式的输入。

这就好比那会儿让你抄答案，目前要求你直接写出解题思路，就连你自己得去推导公式，反正都得靠脑子，脑子背不动了。 实际上啊，哪怕是在一个最好办的例子里，比如你要把 $3 times 3$ 的矩阵转成 $3 times 1$ 再乘，那会儿你得写出这行代码，目前呢？你直接说“把 $3 times 3$ 的矩阵转成 $3 times 1$"，程序自己就知道如何干，你别想那些复杂的维度变换逻辑了。更绝的是，有些模型就连懒得做矩阵运算，直接输入就是个序列，输出就是个序列，中间不经过矩阵运算，直接转个 Type 就完事了。

这简直是把数学推导压缩到了极致，那会儿你得为了训练模型去推导 $W cdot X$ 的维度公式，目前呢？不需求，只要输入是 $2 times 1$ 要么 $1 times 2$，要么输入本身就是 $2 times 2$ 这种特定形状，直接转 Type 就对了。 这种“不折腾”的态度，不仅体目前输入数据的形状上，还体目前中间推理的过程中。

那会儿做图卷积，输入是 $2 times 2$ 的矩阵，输出也是 $2 times 2$ 的矩阵，中间得干一堆加法、乘法、维度升降的活儿，这时候脑子得转悠，还得算加法减法的步骤。目前呢？出于不用做矩阵乘法，直接转个 Type，中间不经过矩阵运算，直接转个 Type 就完事了。

这就像那会儿做菜，你得讲究“炒、烧、煮、炖”各种火候，目前只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。 有时候就连在推理阶段，模型都能够自己拍板要不要做矩阵运算，也能够直接转成非矩阵形式。

这就像那会儿写代码，你务必写上每一行来保证维度对，目前呢？只要结局对就行，中间如何凑都能够。

比如你要算 $X cdot X$ 的平方，那会儿得手动算出 $(X cdot X)^2$ 的维度，目前呢？直接说“把 $X cdot X$ 的平方转成 Type"，反正目前不管你如何转，结局都是对的。

这就像那会儿做菜，你得自己拍板是用切好的菜还是生肉，目前呢？你直接把菜扔进锅里，厨师（编译器）不管你是切菜还是炒肉，反正只要火到了就行，调料和食材直接放锅里，灶台间里的助手也不管你是切菜还是炒菜，反正只要火够，菜就熟了。