如何计算具有numpy的向量和矩阵的"Kronecker积“
"Kronecker积"是指两个向量或矩阵的逐元素相乘得到的新的向量或矩阵。在numpy中，可以使用函数numpy.kron()来计算两个向量或矩阵的Kronecker积。
具体使用方法如下：
- 导入numpy库：
import numpy as np- 定义两个向量或矩阵：
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])- 计算Kronecker积：
result = np.kron(a, b)这样，result就是向量[4, 5, 6, 8, 10, 12, 12, 15, 18]，它是向量a和向量b的Kronecker积。
对于矩阵的Kronecker积，使用方法与向量类似，只需要将矩阵作为参数传入np.kron()函数即可。
Kronecker积在很多领域都有广泛的应用，例如信号处理、图像处理、量子力学等。在信号处理中，Kronecker积可以用于生成多通道信号；在图像处理中，Kronecker积可以用于图像的缩放和旋转等操作；在量子力学中，Kronecker积可以用于描述多粒子系统的状态。
腾讯云提供了丰富的云计算产品，其中与numpy相关的产品包括云服务器、云数据库、云存储等。您可以访问腾讯云官网了解更多产品信息：腾讯云官网。
相关·内容
成功地回答了如何在Python语言中使用numpy计算两个矩阵的张量积。但是，我希望输出采用适当的矩阵格式，以便可以对其执行进一步的计算，而无需手动编辑它。
例如,
I=matrix([[1,0],[0,1]])
print np.tensordot(I, I, axes=0)
给出输出：
[[[[1 0]
[0 1]]
[[0 0]
[0 0]]]
[[[0 0]
[0 0]]
[[1 0]
[0 1]]]]
我希望它的格式是：
[[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]
这样我就可以在程序本身中对它执行进一步
浏览 0提问于2014-05-11得票数 3
1回答
根据这篇文章
矩阵可以用一阶矩阵逼近，我知道在matlab kronecker积中，函数是kron，现在假设我们有下面的矩阵。
a=[2 1 3;4 3 5]
a =
2 1 3
4 3 5
这个矩阵的SVD是
[U E V]=svd(a)
U =
-0.4641 -0.8858
-0.8858 0.4641
E =
7.9764 0 0
0 0.6142 0
V =
-0.5606 0.1382 -0.
浏览 4提问于2014-04-01得票数 0
回答已采纳
Incanter的新手，他想知道基于两个列表的成对乘积的结果创建矩阵的矢量化解决方案是什么样子。更清楚地说，我有两个我创建的列表
(def x (pdf-poisson (range 4) :lambda 2.2))
(def y (pdf-poisson (range 4) :lambda 1.5)).
我现在想要一个4x4矩阵M，使得M(1,1)是x(1)和y(1)的乘积，M(1,2)是x(1)和y(2)的乘积，等等。
在Octave中使用外部产品很容易，所以希望Incanter也支持这一点。
我可以通过跨向量映射函数来轻松地手工编码，但如果可能的话，我想要一种惯用的或向量化的方法。
谢谢
浏览 0提问于2011-12-22得票数 2
回答已采纳
1回答
我想在n*n矩阵中创建k个具有相同值的块(k可以精确地除以行数乘以列数作为n*n )：
例如，当n= 4和k=4 (k可以精确地除以4*4=16)时，矩阵是这样创建的：
1 1 2 2
1 1 2 2
3 3 4 4
3 3 4 4
如果没有for循环，我怎么做呢？
浏览 0提问于2012-10-04得票数 4
回答已采纳
1回答
我有两批载体: W= w1，w2，w3，...
和
V= v1，v2，v3，....
两个批次都以numpy 2D向量[x1，y1，x2，y2...]表示
我想要计算W中的任何元素与V中的元素之间的成对点积，并且我想要一个可能组合的矩阵，即
[ w1.v1，w1.v2，w1.v3，...
w2.v1，w2.v2，w2.v3，...
w3.v1，w3.v2，w3.v3，...
.]
如果w和v是简单的标量，那么这很容易。
但问题是w和v是一维矢量: x，y
我如何在numpy中实现这一点？
谢谢
浏览 22提问于2020-05-24得票数 1
1回答
我正在使用本征库来解决一个有限元问题，在这个问题中，我使用了几个相似的稀疏矩阵来处理我计算的不同类型的导数。要构建稀疏矩阵来解决系统问题，我想使用逗号初始化器，但稀疏矩阵(和)不支持这一点。在这个答案中，Henri确实提出了不受支持的艾根Kronecker产品，尽管我认为这在这里行不通。
在一个NxM网格中，我计算了维数N*M x N*M的几个导数矩阵(稀疏)、Dx2, Dxz,和Dz2。我的求解矩阵如下(K's只是常数，0只是填充-零矩阵，N*M. *M)。
K3*Dx2 + K1*Dz2 K2*Dxz 0 0
浏览 5提问于2021-07-12得票数 0
回答已采纳
1回答
我有如下年度数据集：
year <- c(2016,2017,2018)
xxx <- c(1,2,3)
yyy <- c(4,5,6)
df <- data.frame(year,xxx,yyy)
print(df)
year xxx yyy
1 2016 1 4
2 2017 2 5
3 2018 3 6
其中，列xxx和yyy中的值对应于该年的值。我想扩展这个dataframe (或者创建一个新的dataframe)，它保留相同的列名，但是重复每个值12次(对应于该年的月份)，并在第一列中重复12次。
如下代码所模拟的那样：
year
浏览 2提问于2022-11-14得票数 1
回答已采纳
2回答
我需要在numpy中执行两个矩阵的点积。但是，其中一个实际上在每一行中都具有相同的值。类似于：
array([[0, 0, 0, 0, 0],
[1, 1, 1, 1, 1],
[2, 2, 2, 2, 2]])
为了优化目的，我只将一列存储为一维数组。
是否有一种方法，可以计算这个矩阵和通常的2d矩阵之间的点积，而不需要显式地创建上面的矩阵？
浏览 7提问于2014-10-16得票数 4
回答已采纳
假设有两个大小相同的矩阵，我想计算它们的列向克隆克积的总和。由于有时列的大小很大，所以速度可能很慢。因此，是否存在向量化函数，或者任何函数都可以帮助降低matlab中的复杂性？提前谢谢。
下面提供了具有for-循环的相应matlab代码，d的回答是感兴趣的输出：
A = rand(3,7);
B = rand(3,7);
d = zeros(size(A,1)*size(B,1),1);
for i=1:size(A,2)
d = d + kron(A(:,i),B(:,i));
end
浏览 8提问于2015-08-28得票数 4
回答已采纳
2回答
返回2D向量
、、、、
我正在写一个简单的C++程序来做两个矩阵的kronecker张量积，就像matlab函数一样。
下面是程序：
#include<iostream>
#include<vector>
using namespace std;
vector< vector<double> > kron(vector< vector<double> > &A, vector< vector<double> > &B);
int main()
{
vector< vector<
浏览 2提问于2015-08-13得票数 1
2回答
由两组对应点计算本质矩阵
、、、、
我试着用两个校准的相机重建3d图像。所涉及的步骤之一是计算3x3本质矩阵E，从两组对应的(齐次)点(超过所需的8个) P_a_orig和P_b_orig，以及两个摄像机的3x3内部校准矩阵K_a和K_b。
我们首先要使我们的观点正常化
P_a = inv(K_a) * p_a_orig
和
P_b = inv(K_b) * p_b_orig
我们也知道约束
P_b' * E * P_a = 0
我一直在跟踪它，但是你如何解决最后一个问题，例如，找到E矩阵的九个值？我读过关于这个主题的几个不同的讲稿，但它们都忽略了最后一个关键步骤。很可能是因为它被认为是琐碎的数学，但我不记得我上次做这件
浏览 4提问于2014-09-28得票数 1
在这种情况下，我需要从稀疏矩阵中提取一行，并将其与密集行的点积相乘。使用scipy的csr_matrix，这似乎比使用numpy的密集数组乘法要慢得多。这让我大吃一惊，因为我预计稀疏点积涉及的操作会少得多。下面是一个示例：
import timeit as ti
sparse_setup = 'import numpy as np; import scipy.sparse as si;' + \
'u = si.eye(10000).tocsr()[10];' + \
'v = np.rand
浏览 2提问于2015-11-20得票数 3
2回答
渐近点积结果在列表中
、、、
我有两个渐近矩阵，U和B
>> U
<< Matrix([
[1.0, 0, 0, 0],
[ 0, 1.0, 0, 0],
[ 0, 0, 1.0, 0],
[ 0, 0, 0, 1.0]])
>> B
<< Matrix([
[sqrt(2)/2, 0.5*sqrt(2)*I, 0, 0],
[ 0, 0, 0.5*sqrt(2)*I, sqrt(2)/2],
[
浏览 11提问于2017-12-16得票数 3
回答已采纳
我试图在两个不同维数的矩阵之间使用Numpy中的点乘积。W是(1，5)，X是(3，5)，我不确定我可以使用哪个命令来更改维度，因为我对python还不熟悉。谢谢。
当我尝试运行我的函数时，它会给出一个错误：
ValueError: shapes (1,5) and (3,5) not aligned: 5 (dim 1) != 3 (dim 0)
from numpy.core.memmap import ndarray
def L(w, X, y):
"""
Arguments:
w -- vector of size n representi
浏览 8提问于2022-09-11得票数 -1
假设我有一个这样的矩阵：
a =
1 2
3 4
我想要将矩阵的大小增加一倍，并创建如下内容：
aa =
1 1 2 2
1 1 2 2
3 3 4 4
3 3 4 4
这样，第一个矩阵中的每个元素都传播到较大矩阵中的四个元素。
a(i,j) == aa(2*i-1, 2*j-1)
== aa(2*i , 2*j-1)
== aa(2*i-1, 2*j)
== aa(2*i , 2*j)
有没有什么预定义的
浏览 0提问于2013-01-29得票数 2
回答已采纳
在numpy中，定义矩阵和点积是标准的，如下所示
import numpy as np
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([[7, 8, 9, 10], [11, 12, 13, 14], [15, 16, 17, 18]])
print(a.shape)
print(b.shape)
print(a.dot(b).shape)
如预期的产出：
(2, 3)
(3, 4)
(2, 4)
但令我惊讶的是，下面这些都是同情地失败了
import sympy as sp
a = sp.Matrix([[1, 2, 3], [4, 5,
浏览 0提问于2018-04-20得票数 6
回答已采纳
1回答
将矩阵扩展为块矩阵-索引问题
、、、、
我希望用两种方式展开矩阵，但我无法计算出它的代码；我不需要精确的代码，而只是在文献中寻找一个指针。下面的问题涉及量子力学中换位方程的线性化，我从物理学的角度了解理论，但我不知道我的问题在编程世界中的名字。
我有矩阵A，它是NxN矩阵，在这个例子中，设为N=3；所以A是：
A=[a11 a12 a13
a21 a22 a23
a31 a32 a33]
我想做一个矩阵B，它是N^2xN^2大小。B有块状：
B=[A11 A12 A13
A21 A22 A23
A31 A32 A33]
A11=[a11 0 0
0 a11 0 ...
0
浏览 1提问于2016-07-28得票数 2
回答已采纳
我在MATLAB中计算两个3x11矩阵的点积，这些矩阵是多维的，但我一次只能访问一个“页面”。根据我的数学知识，我希望返回一个3x11矩阵作为结果，但在使用以下代码时：
contact_force(:,:,k)=dot(km(:,:,k),actual_interf(:,:,k))
答案是1x11矩阵的形式
浏览 2提问于2014-01-29得票数 1
我对Numpy函数点：的命名有点困惑
似乎这就是Numpy中用来执行矩阵乘法的方法。然而，“点积”是不同的，它从两个向量产生单个标量：。
有人能解决“点”这个词的这两种用法吗？
浏览 5提问于2018-01-16得票数 6
回答已采纳
numpy.dot文档字符串说：
对于二维阵列，它等价于矩阵乘法，对于一维阵列则等价于向量的内积(没有复共轭)。对于n维，它是a的最后一个轴和b的第二个到最后一个轴上的和积。
但是它没有说明numpy.dot如何用二维array.So计算一维数组，Numpy如何处理一维数组(向量)和二维数组(矩阵)？
我做了一些测试：
In [27]: a
Out[27]:
array([[0, 1, 2],
[3, 4, 5],
[6, 7, 8]])
In [28]: b
Out[28]: array([0, 1, 2])
In [29]: np.dot(a,b)
浏览 4提问于2013-11-21得票数 5
回答已采纳
1回答
在皮卡上。206在Barto和Sutton的强化学习中，关于标量积的结果有一种奇怪的说法：
📷
在我的解释中，A是二维向量的标量乘积的期望:哪个应该是标量，对吗？那么他们是如何得到dxd矩阵的呢？它是标量矩阵(与重复系数对角线，即这个标量积)的缩写吗？
浏览 0提问于2020-09-17得票数 1
回答已采纳
1回答
如果我有一个矩阵A(5000x6000)，这意味着它有n行和m列，a_ij是元素。我想计算一下sum (k=1..m, l=1..m) (a[i,l]*a[j,k]) (即)，它是5000乘5000.怎样才能有效地计算出这样的公式？
提前谢谢。
浏览 0提问于2014-11-30得票数 3
回答已采纳
我读了Levy等人的论文“”，在讨论他们的超参数时，他们说：
向量归一化()如第二节所述，所有向量(即W行)都归一化为单位长度(L2归一化)，使点积运算等价于余弦相似。
然后，我回顾了R- sim2包中text2vec向量相似函数的默认值是L2-范数向量，首先：
sim2(x, y = NULL, method = c("cosine", "jaccard"), norm = c("l2", "none"))
因此，我想知道，这其中的动机是什么，规范化和余弦(无论是在text2vec还是一般情况下)。我试着阅读L2范数，但
浏览 4提问于2018-07-11得票数 6
回答已采纳
我不知道如何解释我想做什么，这样才能从谷歌的搜索中得到有意义的答案。由于这个原因，我也不确定标题这个问题的最佳方式，所以如果标题不清楚，我很抱歉。
假设我有两个矩阵列表，名为a和B。a是一个列矩阵列表，大小相同。B是一个方阵的列表，大小相同。每个列表都有相同的长度。
> a <- list( t(t(c(1,2,3))), t(t(c(-2,1,2))) )
> a
[[1]]
[,1]
[1,] 1
[2,] 2
[3,] 3
[[2]]
[,1]
[1,] -2
[2,] 1
[3,] 2
> B <-
浏览 2提问于2020-06-13得票数 2
回答已采纳
1回答
正规映射与保持切线
、、、、
假设你有一个带有法线地图的三维网格。该网格还具有切线、二值化和法线。
从切线，双元和法线，你可以建立TBN矩阵，它是一个将切线空间转换成世界空间的矩阵。那样的话，要想得到真正的正常，你只需要做这样的事情：
mat3 TBN = mat3(tangent, bitangent, normal);
vec3 realNormal = TBN * normalFromTheNormalMap;
然而，如何从这个系统中得到真实的切线和双切线呢？
浏览 0提问于2017-09-19得票数 2
回答已采纳
给定三个坐标(每个坐标都有x、y和z值)，我如何使用numpy和/或scipy来计算结果平面的倾斜(或倾斜)？
a = np.array([32.49, -39.96,-3.86])
b = np.array([31.39, -39.28, -4.66])
c = np.array([31.14, -38.09,-4.49])
我要使用此计算来过滤屋顶段的LiDAR点云数据集。所以屋顶的角度在30度到60度之间。
我知道我必须旋转由三个坐标定义的平面来计算所需的角度，但我不知道如何使用numpy/scipy来实现这一点。我可能需要的是这样的循环：
更新：
Paul Panzer
浏览 0提问于2017-03-20得票数 1
1回答
从多变量正态分布中取样多个元素
、、、、
我有一个大小为n*m的2D均值矩阵，其中n是样本数，m是数据的维数。我也有n矩阵的m*m，即西格玛是我的方差矩阵的形状n*m*m。我希望从上面的发行版中取样n样本，例如x_i~N(mean[i], sigma[i])。在numpy或使用for循环运行的任何其他标准库中，有什么方法可以做到这一点？
我认为唯一的选择是使用np.random.multivariate_normal()，将均值矩阵平坦为一个向量，并将3D西格玛压平为一个2D块--对角线矩阵。当然，之后还会重新塑造。但是，这意味着我们使用的是形状为(n*m)*(n*m)的样本，它很容易变得异常庞大，只有计算和分配矩阵(如果可能的话)比
浏览 4提问于2021-01-26得票数 0
回答已采纳
在一个简单的例子中，我试图学习如何使用numpy来确定特征向量和值，但是结果看起来不正确。这是我的代码：
import numpy as np
import numpy.linalg as la
# create the matrix
matrix = np.array([[-2, 1, 0], [1, -2, 1], [0, 1, -2]])
print("Matrix:\n", matrix)
# calculate the eigenvalues and vectors
vals, vecs = np.linalg.eigh(matrix)
# print the
浏览 0提问于2018-01-28得票数 1
回答已采纳
1回答
Numpy矩阵乘法行为
、、、
我有一个问题，要理解numpy中的矩阵乘法。例如，我有以下矩阵(2d numpy数组)：
a = [ [ 1. 1. ]
[ 1. 2. ]
[ 1. 3. ] ]
和下面的行向量θ：
theta = [ 1. 1. ]
将a与θ相乘的唯一方法是首先在列向量中转换θ，然后得到结果：
result = [ [ 2. ]
[ 3. ]
[ 4. ] ]
当我将矩阵和行向量相乘时(不进行转换)
result = np.dot(a,theta)
我明白了：
result = [ 2. 3. 4. ]
这怎么可能？我是说，我没有变换矩阵
浏览 3提问于2016-10-22得票数 0
回答已采纳
2回答
向量成块矩阵
、、
我给出了一个向量，并想把它转换成一个块矩阵。考虑一下这个简单的例子：
k <- c(1,2,3)
a <- rep(apply(expand.grid(k, k), 1, prod), each=3)
a
[1] 1 1 1 2 2 2 3 3 3 2 2 2 4 4 4 6 6 6 3 3 3 6 6 6 9 9 9
该向量应以如下形式的块矩阵对齐：
rbind(
cbind(diag(a[1:3]), diag(a[4:6]), diag(a[7:9])),
cbind(diag(a[10:12]), diag(a[13:15]), diag(a[16:18]) ),
cbin
浏览 2提问于2017-10-20得票数 4
回答已采纳
假设我有一个矩阵：
m=[1 2 3;4 5 6; 7 8 9]
我想要MATLAB中的这个矩阵：
a=[1,1,1,2,2,2,2,3,3,3;1,1,1,2,2,2,3,3,3;4,4,4,5,5,5,6,6,6;4,4,4,5,5,5,6,6,6;7,7,7,8,8,8,9,9,9;7,7,7,8,8,8,9,9,9]
请帮忙制作这个矩阵，
提前谢谢你，
浏览 1提问于2014-04-09得票数 0
回答已采纳
3回答
我需要将两个大矩阵相乘，并对它们的列进行排序。
import numpy
a= numpy.random.rand(1000000, 100)
b= numpy.random.rand(300000,100)
c= numpy.dot(b,a.T)
sorted = [argsort(j)[:10] for j in c.T]
这个过程需要大量的时间和内存。有没有办法加快这个过程？如果不是，我如何计算执行此操作所需的RAM？我目前有一个EC2机器，有4 4GB内存，没有交换。
我想知道这个操作是否可以序列化，并且我不必将所有内容都存储在内存中。
浏览 5提问于2014-07-31得票数 8
回答已采纳
我目前正试图为高斯马尔可夫随机场创建一个精确矩阵。假设我在6x6的空间网格中有随机变量。然后我将得到一个36x36的精确矩阵。
现在假设我有一个3x3的邻域，那么我的精度矩阵将是
Q= nnbs[1] -1 0 0 0 0 -1.......0
-1 nnbs[2] -1 0 0 0 0 ......0
0 -1 nnbs[3] -1 0 0 0 ......0
..........................................
浏览 4提问于2012-06-30得票数 3
1回答
计算输出wrt的梯度权重
、、、、
从tensorflow模型开始，我希望能够检索输出相对于权重的梯度。反向传播的目的是计算损失wrt的梯度权值，为了做到这一点，在代码中一定要计算输出wrt的梯度权值。
但我想知道如何使雅可比在API级别，有什么想法吗？
我知道我们可以访问磁带，但我不知道用它做什么，实际上我不需要整个Jacobian，我只需要能够计算J^{*}v的矩阵向量积，其中J^{}是jacobian的转置，v是给定的向量。
谢谢，问候。
浏览 4提问于2019-12-10得票数 2
1回答
假设我有一个1802乘以2的坐标矩阵(经度/纬度)，每一行coord，因此表示空间中的一个点。
[,1] [,2]
[1,] -90.0 -5
[2,] -87.5 -5
[3,] -85.0 -5
[4,] -82.5 -5
[5,] -80.0 -5
[6,] -77.5 -5
我使用geosphere包distGeo函数来计算两点p1和p2之间的测地距离。
distGeo(coord[1,],coord[2,])
我想要建立一个对称的度量矩阵(例如1802*2,1802*2)，表示coord中每个点之间的距离。
尝试循环
for (i in 1:nr
浏览 2提问于2016-03-22得票数 0
回答已采纳
2回答
我有两个MxN维数相同的稀疏矩阵A和B(MxN)，其中M=~100 K，N=~150 K。
我希望计算每一对行之间的余弦距离(即从矩阵A到第1行，从矩阵B到第1行，从矩阵A到第2行，从矩阵B到第2行等等)。
我可以使用for-循环或使用apply函数来完成这一任务，但是这太慢了，比如：
library(slam)
A <- simple_triplet_matrix(1:3, 1:3, 1:3)
B <- simple_triplet_matrix(1:3, 3:1, 1:3)
cosine <- NULL
for (i in 1:(dim(A)[1])) {
a
浏览 1提问于2016-09-06得票数 1
回答已采纳
我想通过T.dot或theano中的else运算从矩阵A*B*C和矩阵B*A*C获得A*A*C的矩阵，其中A，B，C是维度。
有什么简单的方法可以做吗？
浏览 0提问于2016-11-15得票数 0
3回答
考虑以下向量(本质上是2x1矩阵)：
a = sc.array([[1], [2], [3]])
>>> a
[[1]
[2]
[3]]
b = sc.array([[4], [5], [6]])
>>> b
[[4]
[5]
[6]]
可以使用numpy.cross()计算这些向量的叉积。为什么这不起作用：
import numpy as np
np.cross(a, b)
ValueError: incompatible dimensions for cross product
(dimension must be 2 or 3)
但这有关
浏览 3提问于2012-02-13得票数 14
回答已采纳
假设我有一个矩阵: 1，2，3& 4，5，6& 7，8，9，它们看起来像：this。 现在，我想用Python创建这个矩阵，但是我不确定怎么做。 我认为它是这样写的： import numpy as np
np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]]) 或者像这样： import numpy as np
np.array([[1, 4, 7],
[2, 5, 8],
[3, 6, 9]]) 我应该用哪种方式？
浏览 7提问于2021-07-10得票数 1
回答已采纳
我试图在MATLAB中用Python重现一个结果。然而，我似乎不能把它弄对。下面是正确的MATLAB代码：
nx = 5;
ny = 7;
x = linspace(0, 1, nx); dx = x(2) - x(1);
y = linspace(0, 1, ny); dy = y(2) - y(1);
onex = ones(nx, 1);
oney = ones(ny, 1);
Dx = spdiags([onex -2*onex onex], [-1 0 1], nx, nx);
Dy = spdiags([oney -2*oney oney], [-1 0 1], ny, ny
浏览 1提问于2013-06-11得票数 5
回答已采纳
2回答
我的程序的核心是以下几行
import numpy as np
import time
I, J = np.random.randn(20000,800), np.random.randn(10000,800)
d = np.zeros((len(I),1))
for j in range(len(J)):
t0 = time.time()
# Compute distance
matrix_j = np.array([J[j]]).T*np.array([J[j]])
for i in range(len(I)):
matrix_i =
浏览 0提问于2018-05-01得票数 3
回答已采纳
我希望用纯python来表达np.kron函数正在做的事情。 假设我有以下列表： v1 = [1, 0, 0, 1]
v2 = [1, 0, 0, 1] 我想定义一个函数，通过将v1乘以v2中的每个元素来创建列表列表。因此，这两个列表将产生4个列表： [[1 * v1[0]],[0 * v1[1]],[ * v1[3]],[1 * v1[3]]] 目前，我一直在摆弄一堆东西。但是不能让它工作。例如，当我运行这段代码时，我得到一个4x2矩阵： i = [[a*b for a in eye] for b in eye2]
>>[[1, 0, 0, 1], [0, 0, 0, 0]
浏览 9提问于2020-08-02得票数 0
1回答
来自numpy的文档：
numpy.dot(a，b，out=None)
两个数组的点积。具体来说，
如果a和b都是一维阵列，则它是向量的内积(无复共轭)。
如果a和b都是二维数组，则为矩阵乘法，但首选使用matmul或a@b。
，如果a或b是0-D (标量)，则它等价于乘积，并使用numpy.multiply(a，b)或a*b作为首选。
如果a是一个N-D数组，b是一个一维数组，则它是a和b.的最后一个轴上的和积。
如果a是一个N-D数组，b是一个M-D数组(其中)，则它是a的最后一个轴和b:的第二到最后一个轴上的和积。
根据第四点，如果我们取二维数组A和一维数组B的点积，我们应该取A列和
浏览 7提问于2021-03-13得票数 4
回答已采纳
2回答
我正在翻译一些MATLAB代码，在理解MATLAB和Python的numpy之间的语法差异时遇到了一些问题。
在MATLAB中，我有一个6乘6的矩阵，A，以及6个浮点值，a，b，c，d，e，f。
B = A*[a;b;c;d;e;f];
生成一个6乘1的矩阵B。所以我认为MATLAB操作符'*‘必须对应于数值操作符numpy.dot()。
在我的Python代码中，我有相同的矩阵A，以及相同的a，b，c，d，e和f的值。
B = numpy.dot(A, [[a],[b],[c],[d],[e],[f]])
不会产生相同的矩阵B，也不会
B = numpy.dot(A, [a,b,c,
浏览 0提问于2015-07-22得票数 0
2回答
我正在寻找一种有效的方法来计算两个大矩阵的Kronecker积。我尝试使用kronecker()方法，如下所示：
I = diag(700)
data = replicate(15, rnorm(120))
test = kronecker(I,data)
但是，执行需要很长时间，然后会出现以下错误：
Error: cannot allocate vector of size 6.8 Gb
浏览 3提问于2013-09-17得票数 11
回答已采纳
对于modelviewMatrix，我了解如何形成、转换和缩放矩阵。但我无法理解如何使用viewMatrix来形成GLKMatrix4MakeLookAt。有人能解释一下它的工作原理以及如何给参数赋值(眼睛中心向上X，Y，Z)吗？
GLK_INLINE GLKMatrix4 GLKMatrix4MakeLookAt(float eyeX, float eyeY, float eyeZ,
float centerX, float centerY, float centerZ,
浏览 3提问于2013-12-17得票数 1
回答已采纳
如果我们有两个矩阵，如果我们想做矩阵乘法，为什么内维需要相同呢？
我知道一些点阵产品可能有NaNs，但是我们可以忽略它们吗？
浏览 22提问于2018-01-11得票数 1
回答已采纳
2回答
给定A:一个点，B:一个已知存在于平面P上的点，C:平面P的法线。我能通过(A - B)和C之间的点积为零的结果来确定A是否位于P上吗？(或者在一定的精度范围内，我可能会使用0.0001f)
我可能只是遗漏了一些明显的数学缺陷，但这似乎比将点转换到三角形的坐标空间要简单得多，也更快。a.la是的答案
其次，我猜，如果这是一个有效的检查，如果我只想看看点是否在平面上，那么它的计算速度会比使用矩阵变换更快吗？(而不是它是否位于所述平面上的多边形内，我可能会继续使用矩阵变换)
浏览 0提问于2013-06-21得票数 8
回答已采纳
1回答
展开矩阵
、
给定一个矩阵，例如：
1 0 0
0 1 1
1 1 0
我想将每个元素扩展为一个大小为AxA的“子矩阵”，例如，3x3，结果是：
1 1 1 0 0 0 0 0 0
1 1 1 0 0 0 0 0 0
1 1 1 0 0 0 0 0 0
0 0 0 1 1 1 1 1 1
0 0 0 1 1 1 1 1 1
0 0 0 1 1 1 1 1 1
1 1 1 1 1 1 0 0 0
1 1 1 1 1 1 0 0 0
1 1 1 1 1 1 0 0 0
在Python中使用numpy (或PyTorch)最快的方法是什么？
浏览 0提问于2018-06-23得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
