La sémantique de np.dot n'est pas géniale

Comme le souligne Dominique Paul, np.dot a un comportement très hétérogène en fonction des formes des entrées. Ajoutant à la confusion, comme le souligne l'OP dans sa question, étant donné que weights est un tableau 1D, np.array_equal (weights, weights.T) est Vrai ( array_equal teste l'égalité de la valeur et de la forme).

Recommandation: utilisez np.matmul ou l'équivalent @ à la place

Si vous êtes quelqu'un qui débute avec Numpy, je vous conseille d'abandonner complètement np.dot . Ne l'utilisez pas du tout dans votre code. À la place, utilisez np.matmul ou l'opérateur équivalent @ . Le comportement de @ est plus prévisible que celui de np.dot , tout en restant pratique à utiliser. Par exemple, vous obtiendrez le même produit scalaire pour les deux tableaux 1D que vous avez dans votre code comme ceci:

x.shape == (1, N)
y.shape == (M, 1)

Vous pouvez vous prouver que cela donne la même réponse que np.dot avec cet assert:

assert expected_returns_annual @ weights == expected_returns_annual.dot(weights)

Conceptuellement, @ gère ce cas en promouvant les deux tableaux 1D vers les tableaux 2D appropriés (bien que l'implémentation ne le fasse pas nécessairement). Par exemple, si vous avez x avec la forme (N,) et y avec la forme (M,) , si vous faites x @ y , les formes seront promues de telle sorte que:

returns = expected_returns_annual @ weights

Comportement complet de matmul / @

Voici ce que le les documents ont à dire sur matmul / @ et les formes des entrées / sorties :

• Si les deux arguments sont 2D, ils sont multipliés comme des matrices conventionnelles.
• Si l'un des arguments est N-D, N> 2, il est traité comme une pile de matrices résidant dans les deux derniers index et diffusé en conséquence.
• Si le premier argument est 1-D, il est promu en matrice en ajoutant un 1 à ses dimensions. Après la multiplication de la matrice, le 1 préfixé est supprimé.
• Si le deuxième argument est 1-D, il est promu en matrice en ajoutant un 1 à ses dimensions. Après la multiplication de la matrice, le 1 ajouté est supprimé.

Notes: les arguments pour utiliser @ sur dot

Comme le souligne hpaulj dans les commentaires, np. array_equal (x.dot (y), x @ y) pour tous les x et y qui sont 1D ou Tableaux 2D . Alors pourquoi est-ce que je préfère (et pourquoi devriez-vous) @ ? Je pense que le meilleur argument pour utiliser @ est que cela aide à améliorer votre code de manière petite mais significative:

• @ est explicitement un opérateur de multiplication matricielle. x @ y générera une erreur si y est un scalaire, alors que dot fera l'hypothèse que vous vouliez en fait juste une multiplication élémentaire. Cela peut potentiellement entraîner un bogue difficile à localiser dans lequel dot renvoie silencieusement un résultat de garbage (j'ai personnellement rencontré celui-là). Ainsi, @ vous permet d'être explicite sur votre propre intention pour le comportement d'une ligne de code.

• Étant donné que @ est un opérateur, il a une syntaxe courte et intéressante pour contraindre divers types de séquence en tableaux, sans avoir à les convertir explicitement. Par exemple, [0,1,2] @ np.arange (3) est une syntaxe valide.

  • Pour être honnête, alors que [0,1,2] .dot (arr) n'est évidemment pas valide, np.dot ([0,1,2], arr) est valide (bien que plus détaillé que d'utiliser @ ).

• Lorsque vous avez besoin d'étendre votre code pour traiter de nombreuses multiplications matricielles au lieu d'une seule, les cas ND pour @ sont une généralisation conceptuellement simple / vectorisation des cas D inférieurs.