2 डी numpy.power बहुपद विस्तार के लिए

Question

मैं एक ऐसा फ़ंक्शन लिखने की कोशिश कर रहा हूं जो 2 डी-ndarray 2 डी-ndarray को मैप करता है। इनपुट सरणी की पंक्तियों को स्वतंत्र रूप से संसाधित किया जा सकता है और आउटपुट की पंक्तियों और पंक्तियों के बीच 1-से-1 पत्राचार होगा। इनपुट की प्रत्येक पंक्ति के लिए, पंक्ति के लिए दिए गए क्रम के बहुपद विस्तार की गणना की जाएगी (उदाहरण के लिए डॉकस्ट्रिंग देखें)। वर्तमान कार्यान्वयन काम करता है; हालांकि इसे "पावरमैट्रिक्स" में पंक्तियों की पंक्तियों और डुप्लिकेशंस पर स्पष्ट लूप की आवश्यकता होती है)। क्या numpy.power को एक कॉल के साथ एक ही परिणाम प्राप्त करना संभव है? बीटीडब्ल्यू: परिणाम की पंक्तियों में प्रविष्टियों का क्रम मुझसे कोई फर्क नहीं पड़ता।

import numpy 
def polynomialFeatures(x, order): 
    """ Generate polynomial features of given order for data x. 

    For each row of ndarray x, the polynomial expansions are computed, i.e 
    for row [x1, x2] and order 2, the following row of the result matrix is 
    computed: [1, x1, x1**2, x2, x1*x2, x1**2*x2, x2**2, x1*x2**2, x1**2*x2**2] 

    Parameters 
    ---------- 
    x : array-like 
     2-D array; for each of its rows, the polynomial features are created 

    order : int 
     The order of the polynomial features 

    Returns 
    ------- 
    out : ndarray 
     2-D array of shape (x.shape[0], (order+1)**x.shape[1]) containing the 
     polynomial features computed for the rows of the array x 

    Examples 
    -------- 
    >>> polynomialFeatures([[1, 2, 3], [-1, -2, -3]], 2) 
    array([[ 1 3 9 2 6 18 4 12 36 1 3 9 2 6 18 4 12 
      36 1 3 9 2 6 18 4 12 36] 
      [ 1 -3 9 -2 6 -18 4 -12 36 -1 3 -9 2 -6 18 -4 12 
      -36 1 -3 9 -2 6 -18 4 -12 36]]) 
    """ 
    x = numpy.asarray(x) 
    # TODO: Avoid duplication of rows 
    powerMatrix = numpy.array([range(order+1)] * x.shape[1]).T 
    # TODO: Avoid explicit loop, and use numpy's broadcasting 
    F = [] 
    for i in range(x.shape[0]): 
     X = numpy.power(x[i], powerMatrix).T 
     F.append(numpy.multiply.reduce(cartesian(X), axis=1)) 

    return numpy.array(F) 

print numpy.all(polynomialFeatures([[1, 2, 3], [-1, -2, -3]], 2) == 
       numpy.array([[1, 3, 9, 2, 6, 18, 4, 12, 36, 1, 
           3, 9, 2, 6, 18, 4, 12, 36, 1, 3, 
           9, 2, 6, 18, 4, 12, 36], 
          [1, -3, 9, -2, 6, -18, 4, -12, 36, -1, 
           3, -9, 2, -6, 18, -4, 12, -36, 1, -3, 
           9, -2, 6, -18, 4, -12, 36]])) 

धन्यवाद, जनवरी

संपादित करें: लापता समारोह कार्तीय यहाँ परिभाषित किया गया है: Using numpy to build an array of all combinations of two arrays

Answer 1

मूल विचार आयाम (स्थानांतरित करने के लिए अपने मामले, आयाम 0 में है, पंक्तियों की संख्या) जो एक उच्च आयाम में "रास्ते से बाहर" की गणना के लिए अप्रासंगिक है और फिर स्वचालित रूप से इसे प्रसारित करता है।

मुझे यकीन है कि क्या अपने cartesian विधि क्या कर रहा है नहीं कर रहा हूँ, लेकिन यहाँ एक समाधान np.indices का उपयोग करता है X मैट्रिक्स से अधिक अनुक्रमण tuples उत्पन्न करने के लिए है:

import numpy as np 
def polynomial_features(x, order): 
    x = np.asarray(x).T[np.newaxis] 
    n = x.shape[1] 
    power_matrix = np.tile(np.arange(order + 1), (n, 1)).T[..., np.newaxis] 
    X = np.power(x, power_matrix) 
    I = np.indices((order + 1,) * n).reshape((n, (order + 1) ** n)).T 
    F = np.product(np.diagonal(X[I], 0, 1, 2), axis=2) 
    return F.T