Python 评估多项式回归

Question

I need a python function evaluates a polynomial at a set of input points.The function takes as input a vector of polynomial weights, and a vector of input points where x : a vector of input values, and w : a vector of polynomial weights (ordered so the jth element is the linear coefficient for the j th-order monomial, ie, x(j) ). The function outputs the predictions of the polynomial at each input point.

Is there a python built in function for this?

Answer 1

See numpy.poly1d

Construct the polynomial x^2 + 2x + 3:

p = np.poly1d([1, 2, 3])
p(1) # prints 6

Answer 2

It seems you are describing numpy.polyval() :

import numpy as np

# 1 * x**2 + 2 * x**1 + 3 * x**0
# computed at points: [0, 1, 2]
y = np.polyval([1, 2, 3], [0, 1, 2])
print(y)
# [ 3  6 11]

Note that the same could be achieved with np.poly1d() , which should be more efficient if you are computing values from the same polynomial multiple times:

import numpy as np

# 1 * x**2 + 2 * x**1 + 3 * x**0
my_poly_func = np.poly1d([1, 2, 3])
# computed at points: [0, 1, 2]
y = my_poly_func([0, 1, 2])
print(y)
# [ 3  6 11]

---

If you want to use only Python built-ins, you could easily define a polyval() version yourself, eg:

def polyval(p, x):
   return [sum(p_i * x_i ** i for i, p_i in enumerate(p[::-1])) for x_i in x]


y = polyval([1, 2, 3], [0, 1, 2])
print(y)
# [3, 6, 11]

or, more efficiently:

def polyval_horner(p, x):
    y = [] 
    for x_i in x:
        y_i = 0
        for p_i in p:
            y_i = x_i * y_i + p_i
        y.append(y_i)
    return y


y = polyval_horner([1, 2, 3], [0, 1, 2])
print(y)
# [3, 6, 11]

but I would recommend using NumPy unless you have a good reason not to (for example, if your result would overflow with NumPy but not with pure Python).

Answer 3

For fun you could try implementing the basic algorithms, iter being the worst, horner being better (I believe Karatsuba is the best). Here are the first two:

def iterative(coefficients, x): #very inefficient
    i = len(coefficients)
    result = coefficients[i - 1]
    for z in range(i - 1, 0, -1):
        temp = x
        for y in range(z - 1):
            temp = temp * x
        result += temp * coefficients[i - z - 1]
    return (x, result)

def horner(coefficients, x): 
    result = 0
    for c in coefficients:
        result = x * result + c
    return (x, result)

I think numpy is faster in all cases as it goes into the C-level code.