ValueError: tous les tableaux doivent avoir le même nombre de dimensions

Je vais avoir un problème avec np.append.

Je suis en train de dupliquer la dernière colonne de 20x361 matrice n_list_converted en utilisant le code ci-dessous:

n_last = []
n_last = n_list_converted[:, -1]
n_lists = np.append(n_list_converted, n_last, axis=1)

Mais j'obtiens l'erreur:

ValueError: tous les tableaux doivent avoir le même nombre de dimensions

Cependant, j'ai vérifié les dimensions de la matrice en faisant

 print(n_last.shape, type(n_last), n_list_converted.shape, type(n_list_converted))

et je reçois

(20L,) (20L, 361L)

donc les dimensions match? Où est l'erreur?

  • Essayez np.column_stack.
  • Il a travaillé! Mais pourquoi?
InformationsquelleAutor odo22 | 2016-08-09
  1. 12

    Si je commence avec un 3x4 tableau, et concaténer une 3x1 tableau, avec l'axe 1, j'obtiens un 3x5 tableau:

    In [911]: x = np.arange(12).reshape(3,4)
In [912]: np.concatenate([x,x[:,-1:]], axis=1)
Out[912]: 
array([[ 0,  1,  2,  3,  3],
       [ 4,  5,  6,  7,  7],
       [ 8,  9, 10, 11, 11]])
In [913]: x.shape,x[:,-1:].shape
Out[913]: ((3, 4), (3, 1))

    Remarque que les deux entrées pour concaténer ont 2 dimensions.

    Omettre le :, et x[:,-1] est (3,) forme - il est 1d, et donc l'erreur:

    In [914]: np.concatenate([x,x[:,-1]], axis=1)
...
ValueError: all the input arrays must have same number of dimensions

    Le code pour np.append est (dans ce cas où l'axe est spécifié)

    return concatenate((arr, values), axis=axis)

    Donc, avec un léger changement de syntaxe append œuvres. Au lieu d'une liste de il prend 2 arguments. Il imite la liste append est de la syntaxe, mais ne doit pas être confondue avec cette méthode de la liste.

    In [916]: np.append(x, x[:,-1:], axis=1)
Out[916]: 
array([[ 0,  1,  2,  3,  3],
       [ 4,  5,  6,  7,  7],
       [ 8,  9, 10, 11, 11]])

    np.hstack d'abord fait en sorte que toutes les entrées sont atleast_1d, et puis concaténer:

    return np.concatenate([np.atleast_1d(a) for a in arrs], 1)

    Donc il exige la même x[:,-1:] d'entrée. Essentiellement la même action.

    np.column_stack fait également concaténer sur l'axe 1. Mais d'abord, il passe 1d intrants par le biais de

    array(arr, copy=False, subok=True, ndmin=2).T

    Il s'agit d'un moyen de transformer des que (3,) array dans un (3,1) tableau.

    In [922]: np.array(x[:,-1], copy=False, subok=True, ndmin=2).T
Out[922]: 
array([[ 3],
       [ 7],
       [11]])
In [923]: np.column_stack([x,x[:,-1]])
Out[923]: 
array([[ 0,  1,  2,  3,  3],
       [ 4,  5,  6,  7,  7],
       [ 8,  9, 10, 11, 11]])

    Tous ces "piles" peut être pratique, mais dans le long terme, il est important de comprendre les dimensions et la base np.concatenate. Aussi savoir comment trouver le code pour les fonctions de ce genre. J'utilise le ipython ?? magie beaucoup.

    Et dans le temps, les tests, les np.concatenate est sensiblement plus rapide - avec un petit tableau, les couches supplémentaires d'appels de fonction qui fait une grosse différence de temps.

    InformationsquelleAutor hpaulj
  2. 9

    (n) et (n,1) ne sont pas la même forme. Lancez le vecteur d'un tableau à l'aide de la [:, None] notation:

    n_lists = np.append(n_list_converted, n_last[:, None], axis=1)

    Sinon, lors de l'extraction de n_last vous pouvez utiliser

    n_last = n_list_converted[:, -1:]

    pour obtenir un (20, 1) tableau.

    InformationsquelleAutor Aguy
  3. 5

    La raison pour laquelle vous obtenez votre erreur est parce que "1 à n" matrice est différente à partir d'un tableau de longueur n.

    Je recommande d'utiliser hstack() et vstack() à la place.
    Comme ceci:

    import numpy as np
a = np.arange(32).reshape(4,8) # 4 rows 8 columns matrix.
b = a[:,-1:]                    # last column of that matrix.

result = np.hstack((a,b))       # stack them horizontally like this:
#array([[ 0,  1,  2,  3,  4,  5,  6,  7,  7],
#       [ 8,  9, 10, 11, 12, 13, 14, 15, 15],
#       [16, 17, 18, 19, 20, 21, 22, 23, 23],
#       [24, 25, 26, 27, 28, 29, 30, 31, 31]])

    Avis répétées "7, 15, 23, 31" de la colonne.
    Aussi, notez que j'ai utilisé a[:,-1:] au lieu de a[:,-1]. Ma version génère une colonne:

    array([[7],
       [15],
       [23],
       [31]])

    Au lieu d'une ligne array([7,15,23,31])

    Edit: append() est beaucoup plus lent. Lire cette réponse.

    • np.append est plus lente que la liste .append; mais comparable à la stacks. Il utilise np.concatenate.
    • Donc... Comme je le disais à l'aide de append vs stack est de même avec les 2 matrices et stack est mieux pour plus de 2 éléments, de sorte que stack est toujours au moins aussi bon que append.
    InformationsquelleAutor RuRo
  4. 0

    Vous pouvez également cast (n) à (n,1) en plaçant à l'intérieur de crochets [ ].

    par exemple au Lieu de np.append(b,a,axis=0) utilisation np.append(b,[a],axis=0)

    a=[1,2]
b=[[5,6],[7,8]]
np.append(b,[a],axis=0)

    retourne

    array([[5, 6],
       [7, 8],
       [1, 2]])
    InformationsquelleAutor ZZZ