मैं एक समारोह को कम करने का प्रयास कर रहा हूँ। मैं scipy द्वारा प्राप्त प्रगति को प्रदर्शित कर रहा हूं क्योंकि यह चलता है। प्रदर्शित पहला संदेश है। . .

Optimization terminated successfully.
         Current function value: 0.000113
         Iterations: 32
         Function evaluations: 13299
         Gradient evaluations: 33

यह आशाजनक लग रहा है। समस्या यह है कि प्रक्रिया समाप्त नहीं होती है। वास्तव में, यह जैसे संदेशों के साथ जारी है

Warning: Maximum number of iterations has been exceeded.
         Current function value: 0.023312
         Iterations: 50
         Function evaluations: 20553
         Gradient evaluations: 51
Warning: Maximum number of iterations has been exceeded.
         Current function value: 0.068360
         Iterations: 50
         Function evaluations: 20553
         Gradient evaluations: 51
Warning: Maximum number of iterations has been exceeded.
         Current function value: 0.071812
         Iterations: 50
         Function evaluations: 20553
         Gradient evaluations: 51
Warning: Maximum number of iterations has been exceeded.
         Current function value: 0.050061
         Iterations: 50
         Function evaluations: 20553
         Gradient evaluations: 51

अंदर कम से कम करने के लिए कॉल के साथ कोड नीचे दिया गया है:

def one_vs_all(X, y, num_labels, lmbda):
  
  # store dimensions of X that will be reused
  m = X.shape[0]
  n = X.shape[1]

  # append ones vector to X matrix
  X = np.column_stack((np.ones((X.shape[0], 1)),X))

  # create vector in which thetas will be returned
  all_theta = np.zeros((num_labels, n+1))
  
  # choose initial thetas
  #init_theta = np.zeros((n+1, 1))

  for i in np.arange(num_labels):
    # note theta should be first arg in objective func signature followed by X and y
    init_theta = np.zeros((n+1,1))
    theta = minimize(lrCostFunctionReg, x0=init_theta, args=(X, (y == i)*1, lmbda),
                      options={'disp':True, 'maxiter':50})
    all_theta[i] = theta.x
  return all_theta

मैंने कम से कम करने के तरीकों को बदलने की कोशिश की है, पुनरावृत्तियों की संख्या को 30 से कम से कम 1000 तक बदलने की कोशिश की है। मैंने अपने खुद के ग्रेडिएंट फ़ंक्शन की आपूर्ति करने का भी प्रयास किया है। सभी मामलों में, दिनचर्या अंततः एक उत्तर प्रदान करती है, लेकिन यह गलत है। किसी को पता है क्या हो रहा है?

संपादित करें: फ़ंक्शन अलग-अलग है। यहां लागत फ़ंक्शन है, इसके बाद इसकी ढाल (अनियमित, फिर नियमित) है।

def lrCostFunctionReg(theta, X, y, lmbda):
  
  m = X.shape[0]

  # unregularized cost
  h = sigmoid(X @ theta)

  # calculate regularization term
  reg_term = ((lmbda / (2*m)) * (theta[1:,].T @ theta[1:,]))
  
  cost_reg = (1/m) * (-(y.T @ np.log(h)) - ((1 - y).T @ np.log(1 - h))) + reg_term

  return cost_reg

def gradFunction(theta, X, y):
  m = X.shape[0]

  theta = np.reshape(theta,(theta.size,1))
  
  # hypothesis as generated in cost function
  h = sigmoid(X@theta)

  # unregularized gradient
  grad = (1/m) * np.dot(X.T, (h-y))

  return grad

def lrGradFunctionReg(theta, X, y, lmbda):
  
  m = X.shape[0]

  # theta reshaped to ensure proper operation
  theta = np.reshape(theta,(theta.size,1))

  # generate unregularized gradient
  grad = gradFunction(theta, X, y)
  
  # calc regularized gradient w/o touching intercept; essential that only 1 index used
  grad[1:,] = ((lmbda / m) * theta[1:,]) + grad[1:,]

  return grad.flatten()
0
Ryan 20 जिंदा 2021, 23:50
एक त्वरित नज़र से, प्रत्येक लेबल के लिए पैरामीटर को अनुकूलित करना थोड़ा संदिग्ध लगता है। क्या आप सभी पैरामीटरों के लिए एक साथ एक अनुकूलन नहीं चलाना चाहेंगे?
 – 
cel
21 जिंदा 2021, 01:46
सॉल्वर क्यों विफल होता है, यह पूछे बिना सॉल्वर वास्तव में हल करने की कोशिश कर रहा है, हमें दिखाए बिना थोड़ा आशावादी है। मैं यहां अनुमान लगाऊंगा: यह अलग नहीं है।
 – 
sascha
21 जिंदा 2021, 16:33
मैं एक अद्यतन में अतिरिक्त कार्यों को शामिल किया। X 5000x401 है, y 5000x1 है, num_classes 10 है।
 – 
Ryan
21 जिंदा 2021, 21:21

1 उत्तर

सबसे बढ़िया उत्तर

मेरे अपने प्रश्न का उत्तर देने के लिए, मुद्दा वेक्टर आकार में से एक निकला। मैं 2D में कोडिंग का आनंद लेता हूं, लेकिन SciPy ऑप्टिमाइज़ेशन रूटीन केवल कॉलम और रो वैक्टर के साथ काम करते हैं जिन्हें एक सरणी में "चपटा" किया गया है। बहु-आयामी मैट्रिसेस ठीक हैं, लेकिन कॉलम और रो वैक्टर बहुत दूर एक सेतु हैं।

उदाहरण के लिए, यदि y लेबल का वेक्टर है और y.shape (400,1) है, तो आपको y पर y.flatten() का उपयोग करना होगा, जो y.shape = (400,) बना देगा। तब SciPy आपके डेटा के साथ काम करेगा, यह मानते हुए कि अन्य सभी आयाम समझ में आते हैं।

इसलिए, यदि MATLAB मशीन लर्निंग कोड को पायथन में अनुवाद करने के आपके प्रयास रुक गए हैं, तो यह सुनिश्चित करने के लिए जांचें कि आपने अपनी पंक्ति और कॉलम वैक्टर को समतल कर दिया है, विशेष रूप से वे जो एक ग्रेडिएंट फ़ंक्शन द्वारा लौटाए गए हैं।

0
Ryan 23 फरवरी 2021, 02:46