# What does -1 mean in numpy reshape?

## What does -1 mean in numpy reshape?

### Question

A numpy matrix can be reshaped into a vector using reshape function with parameter -1. But I don't know what -1 means here.

For example:

```
a = numpy.matrix([[1, 2, 3, 4], [5, 6, 7, 8]])
b = numpy.reshape(a, -1)
```

The result of `b`

is: `matrix([[1, 2, 3, 4, 5, 6, 7, 8]])`

Does anyone know what -1 means here?
And it seems python assign -1 several meanings, such as: `array[-1]`

means the last element. Can you give an explanation?

### Popular Answer

The criterion to satisfy for providing the new shape is that *'The new shape should be compatible with the original shape'*

numpy allow us to give one of new shape parameter as -1 (eg: (2,-1) or (-1,3) but not (-1, -1)). It simply means that it is an unknown dimension and we want numpy to figure it out. And numpy will figure this by looking at the *'length of the array and remaining dimensions'* and making sure it satisfies the above mentioned criteria

Now see the example.

```
z = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
z.shape
(3, 4)
```

Now trying to reshape with (-1) . Result new shape is (12,) and is compatible with original shape (3,4)

```
z.reshape(-1)
array([ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
```

Now trying to reshape with (-1, 1) . We have provided column as 1 but rows as unknown . So we get result new shape as (12, 1).again compatible with original shape(3,4)

```
z.reshape(-1,1)
array([[ 1],
[ 2],
[ 3],
[ 4],
[ 5],
[ 6],
[ 7],
[ 8],
[ 9],
[10],
[11],
[12]])
```

The above is consistent with `numpy`

advice/error message, to use `reshape(-1,1)`

for a single feature; i.e. single column

Reshape your data using

`array.reshape(-1, 1)`

if your data has asingle feature

New shape as (-1, 2). row unknown, column 2. we get result new shape as (6, 2)

```
z.reshape(-1, 2)
array([[ 1, 2],
[ 3, 4],
[ 5, 6],
[ 7, 8],
[ 9, 10],
[11, 12]])
```

Now trying to keep column as unknown. New shape as (1,-1). i.e, row is 1, column unknown. we get result new shape as (1, 12)

```
z.reshape(1,-1)
array([[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]])
```

The above is consistent with `numpy`

advice/error message, to use `reshape(1,-1)`

for a single sample; i.e. single row

Reshape your data using

`array.reshape(1, -1)`

if it contains asingle sample

New shape (2, -1). Row 2, column unknown. we get result new shape as (2,6)

```
z.reshape(2, -1)
array([[ 1, 2, 3, 4, 5, 6],
[ 7, 8, 9, 10, 11, 12]])
```

New shape as (3, -1). Row 3, column unknown. we get result new shape as (3,4)

```
z.reshape(3, -1)
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
```

And finally, if we try to provide both dimension as unknown i.e new shape as (-1,-1). It will throw an error

```
z.reshape(-1, -1)
ValueError: can only specify one unknown dimension
```

Read more... Read less...

Used to reshape an array.

Say we have a 3 dimensional array of dimensions 2 x 10 x 10:

```
r = numpy.random.rand(2, 10, 10)
```

Now we want to reshape to 5 X 5 x 8:

```
numpy.reshape(r, shape=(5, 5, 8))
```

will do the job.

Note that, once you fix first dim = 5 and second dim = 5, you don't need to determine third dimension. To assist your laziness, python gives the option of -1:

```
numpy.reshape(r, shape=(5, 5, -1))
```

will give you an array of shape = (5, 5, 8).

Likewise,

```
numpy.reshape(r, shape=(50, -1))
```

will give you an array of shape = (50, 4)

You can read more at http://anie.me/numpy-reshape-transpose-theano-dimshuffle/

According to `the documentation`

:

newshape : int or tuple of ints

The new shape should be compatible with the original shape. If an integer, then the result will be a 1-D array of that length. One shape dimension can be

-1. In this case, the value is inferred from the length of the array and remaining dimensions.

numpy.reshape(a,newshape,order{}) check the below link for more info. https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html

for the below example you mentioned the output explains the resultant vector to be a single row.(-1) indicates the number of rows to be 1. if the

```
a = numpy.matrix([[1, 2, 3, 4], [5, 6, 7, 8]])
b = numpy.reshape(a, -1)
```

output:

matrix([[1, 2, 3, 4, 5, 6, 7, 8]])

this can be explained more precisely with another example:

```
b = np.arange(10).reshape((-1,1))
```

output:(is a 1 dimensional columnar array)

array([[0],

```
[1],
[2],
[3],
[4],
[5],
[6],
[7],
[8],
[9]])
```

b = np.arange(10).reshape((1,-1))

output:(is a 1 dimensional row array)

array([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])

It is fairly easy to understand. The "-1" stands for "unknown dimension" which can should be infered from another dimension. In this case, if you set your matrix like this:

```
a = numpy.matrix([[1, 2, 3, 4], [5, 6, 7, 8]])
```

Modify your matrix like this:

```
b = numpy.reshape(a, -1)
```

It will call some deafult operations to the matrix a, which will return a 1-d numpy array/martrix.

However, I don't think it is a good idea to use code like this. Why not try:

```
b = a.reshape(1,-1)
```

It will give you the same result and it's more clear for readers to understand: Set b as another shape of a. For a, we don't how much columns it should have(set it to -1!), but we want a 1-dimension array(set the first parameter to 1!).

**Long story short**: you set some dimensions and let NumPy set the remaining(s).

```
(userDim1, userDim2, ..., -1) -->>
(userDim1, userDim1, ..., TOTAL_DIMENSION - (userDim1 + userDim2 + ...))
```