newarray = np.dstack(mylist)
should work. For example:
import numpy as np
# Here is a list of five 10x10 arrays:
x = [np.random.random((10,10)) for _ in range(5)]
y = np.dstack(x)
print(y.shape)
# (10, 10, 5)
# To get the shape to be Nx10x10, you could use rollaxis:
y = np.rollaxis(y,-1)
print(y.shape)
# (5, 10, 10)
np.dstack returns a new array. Thus, using np.dstack requires as much additional memory as the input arrays. If you are tight on memory, an alternative to np.dstack which requires less memory is to
allocate space for the final array first, and then pour the input arrays into it one at a time.
For example, if you had 58 arrays of shape (159459, 2380), then you could use
y = np.empty((159459, 2380, 58))
for i in range(58):
# instantiate the input arrays one at a time
x = np.random.random((159459, 2380))
# copy x into y
y[..., i] = x
You can use numpy.dstack() to turn a list of 2D arrays into a 3D array:
https://docs.scipy.org/doc/numpy/reference/generated/numpy.dstack.html
If your array sizes are static as you mentioned, you can do the following
output_array = numpy.zeros((14,4,3), dtype=np.float32)
for i in range(14):
mat = numpy.random.rand(4,3)
output_array[i] = mat
you initialize your final array to the size you want and then loop over and assign your matrix (4,3) to the index of that respective loop counter.
The shape and your final matrix is
numpy.shape(output_array)
returns you
(14, 4, 3)
Output is
array([[[ 0.62507486, 0.3246161 , 0.43934602],
[ 0.14476213, 0.76139957, 0.92813474],
[ 0.26556504, 0.02475475, 0.90740073],
[ 0.08017973, 0.97526789, 0.2213122 ]],
[[ 0.70042586, 0.8122381 , 0.79289031],
[ 0.0369414 , 0.10780825, 0.77501732],
[ 0.10386232, 0.86237574, 0.5829311 ],
[ 0.1888348 , 0.85105735, 0.31599012]],
[[ 0.26350111, 0.8787083 , 0.12869285],
[ 0.25927794, 0.25701383, 0.81212741],
[ 0.06661031, 0.53449911, 0.50212061],
[ 0.40009728, 0.78002244, 0.81524432]],
[[ 0.49921468, 0.82028496, 0.51261139],
[ 0.62790054, 0.64566481, 0.02624587],
[ 0.39364958, 0.99537313, 0.33225098],
[ 0.88214922, 0.20252077, 0.78350848]],
[[ 0.29032609, 0.95975012, 0.06733917],
[ 0.24497923, 0.51818371, 0.93520784],
[ 0.80267638, 0.88271469, 0.30779642],
[ 0.57030594, 0.34175804, 0.52563131]],
[[ 0.61039209, 0.57186425, 0.76554799],
[ 0.55681604, 0.33107477, 0.05680386],
[ 0.15465826, 0.13452645, 0.09498007],
[ 0.29682869, 0.93196124, 0.94435322]],
[[ 0.23904459, 0.94893754, 0.97033942],
[ 0.89159942, 0.85306913, 0.02144577],
[ 0.57696968, 0.82578647, 0.33358794],
[ 0.81979036, 0.73351973, 0.027876 ]],
[[ 0.6568135 , 0.25458351, 0.10369358],
[ 0.06151289, 0.00939822, 0.00798484],
[ 0.92518032, 0.19057493, 0.84838325],
[ 0.78189474, 0.15273546, 0.34607282]],
[[ 0.46961641, 0.19778872, 0.1498462 ],
[ 0.55704814, 0.96889585, 0.08894933],
[ 0.48003736, 0.59383452, 0.42212519],
[ 0.78752649, 0.07204869, 0.4215464 ]],
[[ 0.6454156 , 0.84189773, 0.10041234],
[ 0.89345407, 0.60821944, 0.56667495],
[ 0.62806529, 0.67642623, 0.4951494 ],
[ 0.85371262, 0.13159418, 0.3402876 ]],
[[ 0.39828625, 0.50659049, 0.34835485],
[ 0.06839356, 0.74652916, 0.5722388 ],
[ 0.20762053, 0.0692997 , 0.02790474],
[ 0.84786427, 0.98461425, 0.19105092]],
[[ 0.36976317, 0.44268745, 0.23061621],
[ 0.47827819, 0.43044546, 0.90150601],
[ 0.2307732 , 0.61590552, 0.82066673],
[ 0.49611789, 0.4480612 , 0.46685895]],
[[ 0.40907925, 0.15996945, 0.05480348],
[ 0.70230347, 0.00926704, 0.97775948],
[ 0.19834276, 0.20127937, 0.44351548],
[ 0.48512974, 0.07319999, 0.5580616 ]],
[[ 0.35749629, 0.88443983, 0.55465496],
[ 0.61600298, 0.08260803, 0.4010818 ],
[ 0.40910226, 0.31984288, 0.50188118],
[ 0.34836289, 0.14394118, 0.06841569]]], dtype=float32)
Hope that helps
If you know all of your 2D arrays at the start, you can just stack more than two of them:
import numpy as np
a = np.zeros((3, 4))
b = np.zeros((3, 4))
c = np.stack((a, b, a))
If you already have one "stacked" array and want to add another array to it, you can use e.g. numpy.concatenate:
If the array you want to add is "flat", you would have to wrap it in a list to make the dimensions match. By default, the arrays are joined along the first dimension (same as if you were to specify axis=0 in the keyword arguments):
>>> c.shape
(2, 3, 4)
>>> np.array([a]).shape
(1, 3, 4)
c = np.concatenate((c, [a]))
If both arrays are already "stacked", this will also work:
c = np.concatenate((c, c))
You can add a new axis with None/np.newaxis at the start of the array to be appended : a[None,:,:] or simply a[None,...] or just a[None] and for stacking use np.vstack.
Here's a sample run to make things clear -
In [14]: c.shape
Out[14]: (2, 3, 4)
In [15]: d = np.vstack((c,a[None]))
In [16]: d.shape
Out[16]: (3, 3, 4)
In [17]: e = np.vstack((d,a[None]))
In [18]: e.shape
Out[18]: (4, 3, 4)
Workflow
So, the workflow would be :
1) To start off with 2D arrays, use new axes for the arrays :
c = np.vstack( (a[None],b[None]) )
2) For later appending steps, use new axis for the incoming 2D array and use np.vstack to stack with the existing 3D array -
d = np.vstack((c,a[None]))
Using np.concatenate for performance :
np.vstack under the hoods uses np.concatenate as a special case when we need to stack along the first axis. So, if we want to make use of np.concatenate maybe for performance reasons to avoid the additional function call overhead, we need to specify the axis of concatenation, which would be the first axis.
Thus, with np.concatenate -
In [23]: d = np.concatenate((c, a[None]), axis=0)
In [24]: d.shape
Out[24]: (3, 3, 4)
In [25]: e = np.concatenate((d, a[None]), axis=0)
In [26]: e.shape
Out[26]: (4, 3, 4)
You need to use
data.reshape((data.shape[0], data.shape[1], 1))
Example
from numpy import array
data = [[11, 22],
[33, 44],
[55, 66]]
data = array(data)
print(data.shape)
data = data.reshape((data.shape[0], data.shape[1], 1))
print(data.shape)
Running the example first prints the size of each dimension in the 2D array, reshapes the array, then summarizes the shape of the new 3D array.
Result
(3,2)
(3,2,1)
Source :https://machinelearningmastery.com/index-slice-reshape-numpy-arrays-machine-learning-python/
If you want to create a 3D Matrix where every subarray is in the new 3D dimension, wouldn't the final shape be (350,9,5)? In that case, you can simply use:
new_array = np.asarray(data).reshape(350,9,5)
This should work simply by calling the array constructor, i.e. np.array(lst).
>>> l = [np.arange(10).reshape((5,2)) for i in range(10)]
>>> np.array(l).shape
(10, 5, 2)
Do you mean like
>>> lst = [np.arange(10).reshape(5,2)]*10
>>> arr = np.array(lst)
>>> arr.shape
(10, 5, 2)
?
Just doing d3 = array([d1,d2]) seems to work for me:
>>> from numpy import array
>>> # ... create d1 and d2 ...
>>> d1.shape
(18,18)
>>> d2.shape
(18,18)
>>> d3 = array([d1, d2])
>>> d3.shape
(2, 18, 18)
hstack and vstack do no change the number of dimensions of the arrays: they merely put them "side by side". Thus, combining 2-dimensional arrays creates a new 2-dimensional array (not a 3D one!).
You can do what Daniel suggested (directly use numpy.array([d1, d2])).
You can alternatively convert your arrays to 3D arrays before stacking them, by adding a new dimension to each array:
d3 = numpy.vstack([ d1[newaxis,...], d2[newaxis,...] ]) # shape = (2, 18, 18)
In fact, d1[newaxis,...].shape == (1, 18, 18), and you can stack both 3D arrays directly and get the new 3D array (d3) that you wanted.
You could do it with a double for loop (or list comprehension), but for that kind of things it is better to use numpy
import numpy as np
x2D = np.array([[0, 0, 1, 0, 1, 0, 0], [1, 0, 1, 0, 0, 0, 0]])
x3D = x2D[:, :, None]
If you have the list
a = [[0, 0, 1, 0, 1, 0, 0], [1, 0, 1, 0, 0, 0, 0]]
then writing
[[i] for i in a]
will give you
[[[0, 0, 1, 0, 1, 0, 0]], [[1, 0, 1, 0, 0, 0, 0]]].
This is almost what you want, except each element needs to be a list itself. So we can modify it to (thanks Tryph!)
[map(lambda x: [x], item) for item in a]
which will give you
[[[0], [0], [1], [0], [1], [0], [0]], [[1], [0], [1], [0], [0], [0], [0]]].