मैं सोच रहा हूँ कि कैसे मैं numpy के साथ वैश्वीकरण का उपयोग करके इसे फिर से लिख सकता हूँ, यह मानते हुए कि मैं सभी सूचियों को numpy arrays में बदल देता हूँ।

# dcdw1 = m x m array
# a1 = len(x) x m array
# a2 = len(x) x 1 array
# w2 = m x 1 array
# x = len(x) x m array
# y = len(x) x 1 array



for i in range(len(x)):
      for j in range(m):
            for k in range(m):
                dcdw1[k, j] = (a2[i] - y[i]) * a2[i] * (1 - a2[i]) * w2[j] * a1[i, j] * (1 - a1[i, j]) * x[i, k]
      # other stuff that uses dcdw1
-3
Mathias Strohkirch 27 जून 2019, 04:57

2 जवाब

सबसे बढ़िया उत्तर
# dcdw1 = m x m array
# a1 = len(x) x m array
# a2 = len(x) x 1 array
# w2 = m x 1 array
# x = len(x) x m array
# y = len(x) x 1 array

import numpy as np
m = 10
lx = 4 # len(x)

dcdw1 = np.zeros([lx, m, m])
dcdw2 = np.zeros_like(dcdw1)
a1 = np.ones([lx, m]) * 0.5
a2 = np.ones([lx, 1]) * 2
w2 = np.ones([m, 1]) * 3
x = np.ones([lx, m]) * 4
y = np.ones([lx, 1]) * 5

for i in range(lx):
      for j in range(m):
            for k in range(m):
                dcdw1[i, k, j] = (a2[i] - y[i]) * a2[i] * (1 - a2[i]) * w2[j] * a1[i, j] * (1 - a1[i, j]) * x[i][k]
                # Why are you using j on rows and k on columns? anyways

print(dcdw1[-1])

first_term = np.reshape( (a2-y) * a2 * (1-a2), [lx, 1, 1] ) 
# this is on 3d tensor level applied to each matrix seperately
# corresponds to (a2[i] - y[i]) * a2[i] * (1 - a2[i])
print(first_term.shape) # [lx, 1, 1] obviously

a1_term = (a1 * (1-a1))[:, :, np.newaxis]
# On each matrix calculate this vector product [lx, m] and shape to [lx, m, 1]
print(a1_term.shape) 
row_level_term = a1_term * w2 # Element wise multiplication yet again
# w2 is [m, 1] so it is broadcasted to every matrix

row_level_tensor = first_term * row_level_term 
# this applies first term values to every matrix -> [lx, m, 1]
print(row_level_tensor.shape)

x = np.reshape(x, [lx, 1, 10])
# x is weird. Foreach matrix it is used as a coefficient for matrix rows
# x[i][k] # ignoring i, k is basically telling takes this row vector
# and dstack it m times with different coeffs
# to create giant linearly dependent matrices
print(x.shape)
dcdw2 = np.matmul(row_level_tensor, x) # mxm matrix product lx times
print(dcdw2[-1])

यह काफी बदसूरत है लेकिन यह काम पूरा हो जाता है (दो आकार और एक नया अक्ष, उह। लोग आमतौर पर टेंसर पर तत्व-आधारित मैट्रिक्स ऑप्स नहीं करते हैं, मुझे लगता है, कम से कम मैं नहीं करता)। मुझे dcdw1 को ओवरराइट करना पसंद नहीं था। यह ऊपर एक टेंसर बनाता है जहां आपका वर्तमान dcdw1 अंतिम तत्व है। मैंने इसे आपके सीरियल कोड के खिलाफ लूप के साथ चेक किया और आउटपुट समान है। हालाँकि, आपको अपने वर्तमान कोड को थोड़ा सा ट्विक करने की आवश्यकता है।

यहां कोड का Colab लिंक दिया गया है।

सुधार और सुझावों का स्वागत है।

1
Sıddık Açıl 27 जून 2019, 06:20

इस पंक्ति में

dcdw1[k, j] = (a2[i] - y[i]) * a2[i] * (1 - a2[i]) * w2[j] * a1[i, j] * (1 - a1[i, j]) * x[i, k]

लंबा भाग (a2[i] - y[i]) * a2[i] * (1 - a2[i]) * w2[j] * a1[i, j] * (1 - a1[i, j]), मैं इसे temp के रूप में निर्दिष्ट करता हूं, एक len(x) x m सरणी उत्पन्न करेगा, जबकि x एक len(x) x m सरणी है। तो आप यहाँ केवल * ऑपरेटर के साथ एक m x m सरणी प्राप्त नहीं कर सकते।

क्या आपका मतलब है कि आप इस परिणाम को dcdw1[k, j] में प्रत्येक i के लिए range(len(x)) में नीचे के रूप में जोड़ना चाहते हैं?

dcdw1 = np.zeros([m,m])
for i in range(len(x)):
      for j in range(m):
            for k in range(m):
                dcdw1[k, j] += (a2[i] - y[i]) * a2[i] * (1 - a2[i]) * w2[j] * a1[i, j] * (1 - a1[i, j]) * x[i][k]

यदि हां, तो यहां वह कोड है जो आप चाहते हैं:

import numpy as np

# dcdw1 = m x m array
# a2 = len(x) x 1 array
# y = len(x) x 1 array
# w2 = m x 1 array
# a1 = len(x) x m array
# x = len(x) x m 

temp = (a2-y) * a2 * (1-a2) * w2.T * a1 * (1-a1)
dcdw1 = np.dot(temp.T, x).T

मैं w2.T का उपयोग क्यों करूं? चूँकि w2 m x 1 के आकार का एक स्तंभ वेक्टर है। इसे len(x) x m सरणी में प्रसारित नहीं किया जा सकता क्योंकि उनकी पंक्तियों की संख्या मेल नहीं खाती। इसके बजाय मैं w2 को स्थानांतरित कर दूंगा ताकि इसके स्तंभों की संख्या a1 * (1-a1)s' से मेल खाए। temp के समान।

1
Tiendung 27 जून 2019, 06:34