假设我有两个非常大的列表{a1，a2，...}和{b1，b2，...}，其中所有ai和bj都是大型稀疏数组。为了提高内存效率，我将每个列表存储为一个全面的稀疏数组。
现在我想在所有可能的ai和bj对上计算一些函数f，其中每个结果f [ai，bj]再次是稀疏数组。顺便说一句，所有这些稀疏阵列都具有相同的尺寸。
虽然
Flatten[Outer[f, {a1, a2, ...}, {b1, b2, ...}, 1], 1]
返回所需的结果（原则上）它似乎消耗了过多的内存。并非最不重要，因为返回值是稀疏数组的列表，而一个全面的稀疏数组在我感兴趣的情况下效率更高。
是否有一种有效的替代方法来使用Outer
更具体的例子：
{SparseArray[{{1, 1, 1, 1} -> 1, {2, 2, 2, 2} -> 1}],
SparseArray[{{1, 1, 1, 2} -> 1, {2, 2, 2, 1} -> 1}],
SparseArray[{{1, 1, 2, 1} -> 1, {2, 2, 1, 2} -> 1}],
SparseArray[{{1, 1, 2, 2} -> -1, {2, 2, 1, 1} -> 1}],
SparseArray[{{1, 2, 1, 1} -> 1, {2, 1, 2, 2} -> 1}],
SparseArray[{{1, 2, 1, 2} -> 1, {2, 1, 2, 1} -> 1}],
SparseArray[{{1, 2, 2, 1} -> -1, {2, 1, 1, 2} -> 1}],
SparseArray[{{1, 2, 2, 2} -> 1, {2, 1, 1, 1} -> 1}]};
ByteCount[%]
list = SparseArray[%%]
ByteCount[%]
Flatten[Outer[Dot, list, list, 1], 1];
ByteCount[%]
list1x2 = SparseArray[%%]
ByteCount[%]
Flatten[Outer[Dot, list1x2, list, 1], 1];
ByteCount[%]
list1x3 = SparseArray[%%]
ByteCount[%]
等。 Outer（稀疏数组列表）的原始中间结果不仅非常低效，Outer在计算过程中似乎也消耗了过多的内存。
答案 0 :(得分：4)
我将提出一个相当复杂的解决方案但允许在计算期间仅使用大约两倍的内存，以便将最终结果存储为SparseArray。为此付出的代价将是一个慢得多的执行。
这是代码。首先，略微修改（以解决更高维度的稀疏数组）稀疏数组构造 - 解构API，取自this answer：
ClearAll[spart, getIC, getJR, getSparseData, getDefaultElement,
makeSparseArray];
HoldPattern[spart[SparseArray[s___], p_]] := {s}[[p]];
getIC[s_SparseArray] := spart[s, 4][[2, 1]];
getJR[s_SparseArray] := spart[s, 4][[2, 2]];
getSparseData[s_SparseArray] := spart[s, 4][[3]];
getDefaultElement[s_SparseArray] := spart[s, 3];
makeSparseArray[dims_List, jc_List, ir_List, data_List, defElem_: 0] :=
SparseArray @@ {Automatic, dims, defElem, {1, {jc, ir}, data}};
以下函数生成迭代器。迭代器是封装迭代过程的好方法。
ClearAll[makeTwoListIterator];
makeTwoListIterator[fname_Symbol, a_List, b_List] :=
With[{indices = Flatten[Outer[List, a, b, 1], 1]},
With[{len = Length[indices]},
Module[{i = 0},
ClearAll[fname];
fname[] := With[{ind = ++i}, indices[[ind]] /; ind <= len];
fname[] := Null;
fname[n_] :=
With[{ind = i + 1}, i += n;
indices[[ind ;; Min[len, ind + n - 1]]] /; ind <= len];
fname[n_] := Null;
]]];
请注意，我可以实现上述函数更多内存 - 有效且不使用Outer，但对于我们的目的，这不是主要关注点。
这是一个更专业的版本，它为两维索引对生成交互。
ClearAll[make2DIndexInterator];
make2DIndexInterator[fname_Symbol, i : {iStart_, iEnd_}, j : {jStart_, jEnd_}] :=
makeTwoListIterator[fname, Range @@ i, Range @@ j];
make2DIndexInterator[fname_Symbol, ilen_Integer, jlen_Integer] :=
make2DIndexInterator[fname, {1, ilen}, {1, jlen}];
这是如何工作的：
In[14]:=
makeTwoListIterator[next,{a,b,c},{d,e}];
next[]
next[]
next[]
Out[15]= {a,d}
Out[16]= {a,e}
Out[17]= {b,d}
我们也可以使用它来获得批量结果：
In[18]:=
makeTwoListIterator[next,{a,b,c},{d,e}];
next[2]
next[2]
Out[19]= {{a,d},{a,e}}
Out[20]= {{b,d},{b,e}}
，我们将使用第二种形式。
此函数将通过获取数据块（也以SparseArray形式）并将它们粘合在一起来迭代地构建SparseArray对象。它基本上是this答案中使用的代码，打包成函数。它接受用于生成下一个数据块的代码片段，包含在Hold中（我可以选择使其成为HoldAll）
Clear[accumulateSparseArray];
accumulateSparseArray[Hold[getDataChunkCode_]] :=
Module[{start, ic, jr, sparseData, dims, dataChunk},
start = getDataChunkCode;
ic = getIC[start];
jr = getJR[start];
sparseData = getSparseData[start];
dims = Dimensions[start];
While[True, dataChunk = getDataChunkCode;
If[dataChunk === {}, Break[]];
ic = Join[ic, Rest@getIC[dataChunk] + Last@ic];
jr = Join[jr, getJR[dataChunk]];
sparseData = Join[sparseData, getSparseData[dataChunk]];
dims[[1]] += First[Dimensions[dataChunk]];
];
makeSparseArray[dims, ic, jr, sparseData]];
这个功能是主要功能，将它们放在一起：
ClearAll[sparseArrayOuter];
sparseArrayOuter[f_, a_SparseArray, b_SparseArray, chunkSize_: 100] :=
Module[{next, wrapperF, getDataChunkCode},
make2DIndexInterator[next, Length@a, Length@b];
wrapperF[x_List, y_List] := SparseArray[f @@@ Transpose[{x, y}]];
getDataChunkCode :=
With[{inds = next[chunkSize]},
If[inds === Null, Return[{}]];
wrapperF[a[[#]] & /@ inds[[All, 1]], b[[#]] & /@ inds[[All, -1]]]
];
accumulateSparseArray[Hold[getDataChunkCode]]
];
在这里，我们首先生成迭代器，它将为我们提供索引对列表的按需部分，用于提取元素（也是SparseArrays）。请注意，我们通常会一次从两个大输入SparseArray - s中提取多个元素，以加快代码速度。我们一次处理的对数由可选的chunkSize参数控制，默认为100。然后我们构造代码来处理这些元素并将结果放回SparseArray，我们使用辅助函数wrapperF。迭代器的使用并不是绝对必要的（可以使用Reap - Sow代替，与其他答案一样），但允许我将迭代逻辑与稀疏数组的泛型累积逻辑分离。
首先，我们准备大型稀疏数组并测试我们的功能：
In[49]:=
arr = {SparseArray[{{1,1,1,1}->1,{2,2,2,2}->1}],SparseArray[{{1,1,1,2}->1,{2,2,2,1}->1}],
SparseArray[{{1,1,2,1}->1,{2,2,1,2}->1}],SparseArray[{{1,1,2,2}->-1,{2,2,1,1}->1}],
SparseArray[{{1,2,1,1}->1,{2,1,2,2}->1}],SparseArray[{{1,2,1,2}->1,{2,1,2,1}->1}]};
In[50]:= list=SparseArray[arr]
Out[50]= SparseArray[<12>,{6,2,2,2,2}]
In[51]:= larger = sparseArrayOuter[Dot,list,list]
Out[51]= SparseArray[<72>,{36,2,2,2,2,2,2}]
In[52]:= (large= sparseArrayOuter[Dot,larger,larger])//Timing
Out[52]= {0.047,SparseArray[<2592>,{1296,2,2,2,2,2,2,2,2,2,2}]}
In[53]:= SparseArray[Flatten[Outer[Dot,larger,larger,1],1]]==large
Out[53]= True
In[54]:= MaxMemoryUsed[]
Out[54]= 21347336
现在我们进行功率测试
In[55]:= (huge= sparseArrayOuter[Dot,large,large,2000])//Timing
Out[55]= {114.344,SparseArray[<3359232>,{1679616,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2}]}
In[56]:= MaxMemoryUsed[]
Out[56]= 536941120
In[57]:= ByteCount[huge]
Out[57]= 262021120
In[58]:= (huge1 = Flatten[Outer[Dot,large,large,1],1]);//Timing
Out[58]= {8.687,Null}
In[59]:= MaxMemoryUsed[]
Out[59]= 2527281392
对于这个特定的例子，建议的方法比直接使用Outer的内存效率高5倍，但速度慢约15倍。我不得不调整chunksize参数（默认为100，但对于上面我使用2000，以获得最佳速度/内存使用组合）。我的方法仅用作存储最终结果所需内存的两倍的峰值。与基于Outer的方法相比，内存节省程度将取决于所讨论的稀疏数组。
答案 1 :(得分：0)
如果lst1和lst2是您的列表，
Reap[
Do[Sow[f[#1[[i]], #2[[j]]]],
{i, 1, Length@#1},
{j, 1, Length@#2}
] &[lst1, lst2];
] // Last // Last
完成工作并且可能更节省内存。另一方面，也许不是。纳赛尔是对的，一个明确的例子是有用的。
编辑：使用Nasser随机生成的数组，对于len=200，MaxMemoryUsed[]表示此表单需要170MB，而问题中的Outer表单需要435MB。
答案 2 :(得分：0)
使用您的示例list数据，我相信您会发现Append对SparseArray非常有帮助。
acc = SparseArray[{}, {1, 2, 2, 2, 2, 2, 2}]
Do[AppendTo[acc, i.j], {i, list}, {j, list}]
Rest[acc]
我需要Rest删除结果中的第一个零填充张量。种子SparseArray的第二个参数必须是带有前缀1的每个元素的维度。您可能需要明确指定种子SparseArray的背景以优化性能。