La différence entre la np.dot et np.multipliez par np.somme binaire d'entropie croisée calcul de la perte de

J'ai essayé le code suivant, mais n'ai pas trouvé la différence entre np.dot et np.multipliez par np.somme

Ici est np.dot code

logprobs = np.dot(Y, (np.log(A2)).T) + np.dot((1.0-Y),(np.log(1 - A2)).T)
print(logprobs.shape)
print(logprobs)
cost = (-1/m) * logprobs
print(cost.shape)
print(type(cost))
print(cost)

Sa sortie est

(1, 1)
[[-2.07917628]]
(1, 1)
<class 'numpy.ndarray'>
[[ 0.693058761039 ]]

Voici le code pour np.multipliez par np.somme

logprobs = np.sum(np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2)))
print(logprobs.shape)         
print(logprobs)
cost = - logprobs / m
print(cost.shape)
print(type(cost))
print(cost)

Sa sortie est

()
-2.07917628312
()
<class 'numpy.float64'>
0.693058761039

Je suis incapable de comprendre le type et la forme de la différence alors que la valeur du résultat est le même dans les deux cas

Même dans le cas de compression de l'ancien code valeur de coût devient que plus tard, mais le type reste la même

cost = np.squeeze(cost)
print(type(cost))
print(cost)

de sortie est

<class 'numpy.ndarray'>
0.6930587610394646
np.sum retourne un scalaire, np.dot n'est pas...
Pour obtenir une réponse concrète, vous devriez probablement vous offrir les formes de la saisie des tableaux. En général, ce que vous voyez, c'est que np.sum toujours par défaut sommes sur l'ensemble de l'entrée et retourne un scalaire. np.dot seulement sommes sur un axe (ce qui, dans votre cas semble être le seul), et conserve les dimensions.
Ce que vous faites est le calcul de la binary cross-entropy loss et les deux approches que vous avez essayé de l'équivalent, qui est pourquoi vous obtenez le même résultat. Il n'est pas clair ce que votre question réelle est d'environ.
En fait, je cherchais une valeur scalaire en réponse de np.dot
Pour obtenir une valeur scalaire, vous devez utiliser des tableaux 1d, pas de la 2d.

OriginalL'auteur Asad Shakeel | 2018-01-11

  1. 12

    Ce que vous faites est le calcul de la binaire entropie croisée mesures de mauvaises prédictions (ici: A2) du modèle sont comparés à la vraie sorties (ici: Y).

    Voici un exemple reproductible pour votre cas, ce qui doit expliquer pourquoi vous obtenez un scalaire dans le second cas, à l'aide de np.sum

    In [88]: Y = np.array([[1, 0, 1, 1, 0, 1, 0, 0]])

In [89]: A2 = np.array([[0.8, 0.2, 0.95, 0.92, 0.01, 0.93, 0.1, 0.02]])

In [90]: logprobs = np.dot(Y, (np.log(A2)).T) + np.dot((1.0-Y),(np.log(1 - A2)).T)

# `np.dot` returns 2D array since its arguments are 2D arrays
In [91]: logprobs
Out[91]: array([[-0.78914626]])

In [92]: cost = (-1/m) * logprobs

In [93]: cost
Out[93]: array([[ 0.09864328]])

In [94]: logprobs = np.sum(np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2)))

# np.sum returns scalar since it sums everything in the 2D array
In [95]: logprobs
Out[95]: -0.78914625761870361

    Noter que le np.dot sommes le long de seulement les dimensions intérieures qui correspondent ici (1x8) and (8x1). Ainsi, la 8s auront disparu lors de la dot de produit ou de multiplication de matrice ce qui donne le résultat que (1x1) qui est juste un scalaire mais retourné comme tableau 2D de forme (1,1).

    Aussi, et surtout notez qu'ici, np.dot est exactement comme np.matmul depuis les entrées sont des tableaux 2D (c'est à dire les matrices)

    In [107]: logprobs = np.matmul(Y, (np.log(A2)).T) + np.matmul((1.0-Y),(np.log(1 - A2)).T)

In [108]: logprobs
Out[108]: array([[-0.78914626]])

In [109]: logprobs.shape
Out[109]: (1, 1)

    Résultat de retour en tant que scalaire valeur

    np.dot ou np.matmul retourne quel que soit le tableau qui en résulte forme serait, basée sur la saisie des tableaux. Même avec out= argument, il n'est pas possible de retourner un scalaire, si les entrées sont en 2D tableaux. Cependant, nous pouvons utiliser np.asscalar() sur le résultat pour le convertir en un scalaire si le résultat de la matrice est de la forme (1,1) (ou plus généralement d'une scalaire valeur enveloppé dans un nD tableau)

    In [123]: np.asscalar(logprobs)
Out[123]: -0.7891462576187036

In [124]: type(np.asscalar(logprobs))
Out[124]: float

    ndarray de la taille 1 à la scalaire valeur

    In [127]: np.asscalar(np.array([[[23.2]]]))
Out[127]: 23.2

In [128]: np.asscalar(np.array([[[[23.2]]]]))
Out[128]: 23.2
    Ne pouvons-nous pas obtenir la valeur scalaire en utilisant simplement np.dot() dans ce cas? Parce que c'est en donnant la même réponse que np.multiply() avec np.sum().
    ajout d'un hack pour convertir le résultat scalaire 🙂
    Merci!!!! J'avais upvote vous plus d'une fois si je pouvais 🙂
    Belle explication. Sauvé beaucoup de temps.

    OriginalL'auteur kmario23

  2. 36

    np.dot est le produit scalaire de deux matrices.

    |A B| . |E F| = |A*E+B*G A*F+B*H|
|C D|   |G H|   |C*E+D*G C*F+D*H|

    Alors que np.multiply un élément-sage de multiplication de deux matrices.

    |A B| ⊙ |E F| = |A*E B*F|
|C D|   |G H|   |C*G D*H|

    Lorsqu'il est utilisé avec np.sum, le résultat étant égales agit simplement d'une coïncidence.

    >>> np.dot([[1,2], [3,4]], [[1,2], [2,3]])
array([[ 5,  8],
       [11, 18]])
>>> np.multiply([[1,2], [3,4]], [[1,2], [2,3]])
array([[ 1,  4],
       [ 6, 12]])

>>> np.sum(np.dot([[1,2], [3,4]], [[1,2], [2,3]]))
42
>>> np.sum(np.multiply([[1,2], [3,4]], [[1,2], [2,3]]))
23
    qu'en est seulement à l'aide de * de multiplier deux matrices?
    À l'aide de la * de multiplier les matrices aussi ne de l'élément de sage multiplicaiton, comme le ⊙ et np.multiply de l'opérateur.
    Un excellent (car concis) réponse.
    hé, pouvez-vous expliquer ce qu'est np.matmul() ne
    Il effectue une multiplication de matrice. Veuillez voir ma réponse ci-dessus pour plus d'explication!

    OriginalL'auteur Anuj Gautam

  3. 3

    Si Y et A2 sont (1,N) ensembles, puis np.dot(Y,A.T) va produire une (1,1) résultat. Il est en train de faire une multiplication de matrice de a (1,N) avec a (N,1). Le N's sont additionnés, laissant l' (1,1).

    Avec multiply le résultat est (1,N). La somme de toutes les valeurs, et le résultat est un scalaire.

    Si Y et A2 étaient (N,) en forme (même nombre d'éléments, mais 1d), la np.dot(Y,A2) (pas de .T) serait également produire un scalaire. De np.dot documentation:

    Pour les tableaux 2d, il est équivalent à la multiplication de matrice, et, pour les 1-D tableaux de produit scalaire des vecteurs

    Renvoie le produit scalaire de a et b. Si a et b sont des scalaires ou les deux tableaux 1d puis un scalaire est retourné, sinon un tableau est retourné.

    squeeze réduit tous les taille 1 dimensions, mais encore retourne un tableau. Dans numpy un tableau peut avoir un nombre quelconque de dimensions (de 0 à 32). Ainsi, une 0d tableau est possible. Comparer la forme de np.array(3), np.array([3]) et np.array([[3]]).

    OriginalL'auteur hpaulj

  4. 0
    In this example it just not a coincidence. Lets take an example we have two (1,3) and (1,3) matrices. 
// Lets code 

import numpy as np

x1=np.array([1, 2, 3]) // first array
x2=np.array([3, 4, 3]) // second array

//Then 

X_Res=np.sum(np.multiply(x1,x2)) 
// will result 20 as it will be calculated as - (1*3)+(2*4)+(3*3) , i.e element wise
// multiplication followed by sum.

Y_Res=np.dot(x1,x2.T) 

// in order to get (1,1) matrix) from a dot of (1,3) matrix and //(1,3) matrix we need to //transpose second one. 
//Hence|1 2 3| * |3|
//               |4| = |1*3+2*4+3*3| = |20|
//               |3|
// will result 20 as it will be (1*3)+(2*4)+(3*3) , i.e. dot product of two matrices

print X_Res //20

print Y_Res //20

    OriginalL'auteur Ashish S