Hướng dẫn exponential decay fitting python - phân rã theo cấp số nhân phù hợp với python

Bạn có hai tùy chọn:

1. Tuyến tính hóa hệ thống và phù hợp với một dòng vào nhật ký của dữ liệu.
2. Sử dụng bộ giải phi tuyến tính (ví dụ:

   import numpy as np
   
   # Set a seed for the random number generator so we get the same random numbers each time
   np.random.seed(20210706)
   
   # Create fake x-data
   x = np.arange(10)
   # Create fake y-data
   a = 4.5
   b = 0.5
   c = 50
   y = a * np.exp(b * x) + c  # Use the second formulation from above
   y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

   8

Tùy chọn đầu tiên là nhanh nhất và mạnh mẽ nhất. Tuy nhiên, nó đòi hỏi bạn phải biết A-Offset A-Priori, nếu không thì không thể tuyến tính hóa phương trình. .

Nếu bạn sử dụng phương pháp phi tuyến tính, đó là a) không được đảm bảo để hội tụ và mang lại giải pháp, b) sẽ chậm hơn nhiều, c) đưa ra ước tính kém hơn nhiều về độ không đảm bảo trong các tham số của bạn và D) thường ít chính xác hơn nhiều . Tuy nhiên, một phương pháp phi tuyến tính có một lợi thế rất lớn so với đảo ngược tuyến tính: nó có thể giải quyết một hệ phương trình phi tuyến tính. Trong trường hợp của bạn, điều này có nghĩa là bạn không cần phải biết

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

4 trước.

Chỉ để đưa ra một ví dụ, hãy giải quyết cho y = a * exp (k * t) với một số dữ liệu ồn ào bằng cả phương thức tuyến tính và phi tuyến:

import numpy as np
import matplotlib.pyplot as plt
import scipy as sp
import scipy.optimize


def main():
    # Actual parameters
    A0, K0, C0 = 2.5, -4.0, 2.0

    # Generate some data based on these
    tmin, tmax = 0, 0.5
    num = 20
    t = np.linspace(tmin, tmax, num)
    y = model_func(t, A0, K0, C0)

    # Add noise
    noisy_y = y + 0.5 * (np.random.random(num) - 0.5)

    fig = plt.figure()
    ax1 = fig.add_subplot(2,1,1)
    ax2 = fig.add_subplot(2,1,2)

    # Non-linear Fit
    A, K, C = fit_exp_nonlinear(t, noisy_y)
    fit_y = model_func(t, A, K, C)
    plot(ax1, t, y, noisy_y, fit_y, (A0, K0, C0), (A, K, C0))
    ax1.set_title('Non-linear Fit')

    # Linear Fit (Note that we have to provide the y-offset ("C") value!!
    A, K = fit_exp_linear(t, y, C0)
    fit_y = model_func(t, A, K, C0)
    plot(ax2, t, y, noisy_y, fit_y, (A0, K0, C0), (A, K, 0))
    ax2.set_title('Linear Fit')

    plt.show()

def model_func(t, A, K, C):
    return A * np.exp(K * t) + C

def fit_exp_linear(t, y, C=0):
    y = y - C
    y = np.log(y)
    K, A_log = np.polyfit(t, y, 1)
    A = np.exp(A_log)
    return A, K

def fit_exp_nonlinear(t, y):
    opt_parms, parm_cov = sp.optimize.curve_fit(model_func, t, y, maxfev=1000)
    A, K, C = opt_parms
    return A, K, C

def plot(ax, t, y, noisy_y, fit_y, orig_parms, fit_parms):
    A0, K0, C0 = orig_parms
    A, K, C = fit_parms

    ax.plot(t, y, 'k--', 
      label='Actual Function:\n $y = %0.2f e^{%0.2f t} + %0.2f$' % (A0, K0, C0))
    ax.plot(t, fit_y, 'b-',
      label='Fitted Function:\n $y = %0.2f e^{%0.2f t} + %0.2f$' % (A, K, C))
    ax.plot(t, noisy_y, 'ro')
    ax.legend(bbox_to_anchor=(1.05, 1.1), fancybox=True, shadow=True)

if __name__ == '__main__':
    main()

Lưu ý rằng giải pháp tuyến tính cung cấp kết quả gần hơn nhiều với các giá trị thực tế. Tuy nhiên, chúng tôi phải cung cấp giá trị YFORSET để sử dụng giải pháp tuyến tính. Giải pháp phi tuyến tính không yêu cầu kiến ​​thức a-priori này.

• Ví dụ dữ liệu
• Phương pháp 1: Polyfit
• Phương pháp 2: Curve_fit
• So sánh các phương pháp
• Nội suy và ngoại suy (dự báo/dự đoán/ước tính)
• Sử dụng một lô thanh

⇦ Quay lại

Ví dụ dữ liệu

Phương pháp 1: Polyfit

Nếu bạn có một tập hợp các điểm dữ liệu trông giống như chúng tăng lên nhanh chóng, có thể rất hữu ích khi phù hợp với chúng với một dòng tăng theo cấp số nhân, theo cấp số nhân để mô tả hình dạng chung của dữ liệu:

Dòng mà bạn cần phù hợp để đạt được hình dạng này sẽ là hình ảnh được mô tả bởi hàm hàm mũ, đó là bất kỳ chức năng nào của hình thức:

\ (y = ab^x + c \)

hoặc\(AB^x = Ae^{x\ln(B)}\)). The important thing to realise is that an exponential function can be fully defined with three constants. We will use the second of these formulations, which can be written in Python as

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

6 where

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

7 is the exponential function \(e^x\) from the Numpy package (renamed

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

8 in our examples).

Ví dụ dữ liệu

Phương pháp 1: Polyfit

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

Tiếng ồn ngẫu nhiên đang được thêm vào với hàm

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

9 từ Numpy rút các mẫu ngẫu nhiên từ phân phối bình thường (Gaussian). Chúng ta hãy xem xét dữ liệu ví dụ này trông như thế nào trên một biểu đồ phân tán:

import matplotlib.pyplot as plt

# Formatting options for plots
A = 6  # Want figure to be A6
plt.rc('figure', figsize=[46.82 * .5**(.5 * A), 33.11 * .5**(.5 * A)])
plt.rc('text', usetex=True)
plt.rc('font', family='serif')
plt.rc('text.latex', preamble=r'\usepackage{textgreek}')

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

Phương pháp 1: Polyfit

Phương thức này chỉ hoạt động khi \ (c = 0 \), tức là khi bạn muốn lắp một đường cong với phương trình \ (y = ae^{bx} \) với dữ liệu của bạn. Nếu bạn muốn lắp một đường cong với phương trình \ (y = ae^{bx} + c \) với \ (c \ neq 0 \), bạn sẽ cần sử dụng phương pháp 2.\(c = 0\), ie when you want to fit a curve with equation \(y = ae^{bx}\) to your data. If you want to fit a curve with equation \(y = ae^{bx} + c\) with \(c \neq 0\) you will need to use method 2.

Lệnh

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

0 từ Numpy được sử dụng để phù hợp với hàm đa thức với dữ liệu. Điều này có vẻ hơi lạ: tại sao chúng ta cố gắng phù hợp với hàm đa thức với dữ liệu khi chúng ta muốn phù hợp với hàm số mũ? Câu trả lời là chúng ta có thể chuyển đổi hàm hàm mũ thành đa thức bằng cách sử dụng thực tế là:

\ (y = ae^{bx} \ ngụ ý \ ln (y) = \ ln (a) + bx \)

Bởi vì chúng ta có thể lấy logarit tự nhiên của cả hai bên. Điều này tạo ra một phương trình tuyến tính \ (f (x) = mx + c \) trong đó:\(f(x) = mx + c\) where:

• \ (f (x) = \ ln (y) \)
• \ (m = b \)
• \ (c = \ ln (a) \)

Vì vậy,

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

0 có thể được sử dụng để phù hợp \ (\ ln (y) \) so với \ (x \):\(\ln(y)\) against \(x\):

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

Đa thức này bây giờ có thể được chuyển đổi trở lại thành theo cấp số nhân:

# Convert the polynomial back into an exponential
a = np.exp(p[1])
b = p[0]
x_fitted = np.linspace(np.min(x), np.max(x), 100)
y_fitted = a * np.exp(b * x_fitted)

Hãy cùng xem sự phù hợp:

import matplotlib.pyplot as plt

ax = plt.axes()
ax.scatter(x, y, label='Raw data')
ax.plot(x_fitted, y_fitted, 'k', label='Fitted curve')
ax.set_title('Using polyfit() to fit an exponential function')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')
ax.legend()

Phương pháp này có nhược điểm của các giá trị nhỏ nhấn mạnh quá số mũ. Hành động biến đổi hàm đa thức thành theo cấp số nhân có tác dụng tăng các giá trị lớn nhiều hơn so với các giá trị nhỏ, và do đó nó có tác dụng tăng khoảng cách đến đường cong được trang bị cho các giá trị lớn hơn so với các giá trị nhỏ . Điều này có thể được giảm thiểu bằng cách thêm một ‘trọng lượng tỷ lệ thuận với \ (y \): Nói với

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

0 để cho vay nhiều hơn đối với các điểm dữ liệu với giá trị y lớn:\(y\): tell

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

0 to lend more importance to data points with a large y-value:

# Fit a weighted polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1, w=np.sqrt(y))

# Convert the polynomial back into an exponential
a = np.exp(p[1])
b = p[0]
x_fitted_weighted = np.linspace(np.min(x), np.max(x), 100)
y_fitted_weighted = a * np.exp(b * x_fitted_weighted)

# Plot
ax = plt.axes()
ax.scatter(x, y, label='Raw data')
ax.plot(x_fitted, y_fitted, 'k', label='Fitted curve, unweighted')
ax.plot(x_fitted_weighted, y_fitted_weighted, 'k--', label='Fitted curve, weighted')
ax.set_title('Using polyfit() to fit an exponential function')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')
ax.legend()

Sử dụng một trọng lượng đã cải thiện sự phù hợp.

Phương pháp 2: Curve_fit

Từ Scipy Pacakge, chúng ta có thể nhận được chức năng

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

4. Điều này là tổng quát hơn

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

0 (chúng ta có thể phù hợp với bất kỳ loại chức năng nào chúng ta thích, theo cấp số nhân hay không) nhưng nó phức tạp hơn ở chỗ đôi khi chúng ta cần đưa ra dự đoán ban đầu về những gì hằng số có thể để nó hoạt động.

Hãy để sử dụng dữ liệu ví dụ ban đầu của chúng tôi (với \ (c \ neq 0 \)):\(c \neq 0\)):

import numpy as np
import matplotlib.pyplot as plt

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Create a plot
ax = plt.axes()
ax.scatter(x, y)
ax.set_title('Example Data')
ax.set_ylabel('y-Values')
ax.set_ylim(0, 500)
ax.set_xlabel('x-Values')

Bây giờ, hãy để phù hợp với hàm \ (y = ae^{bx} + c \). Điều này được thực hiện bằng cách xác định nó là hàm lambda (tức là là một đối tượng chứ không phải là lệnh) của biến giả \ (t \) và sử dụng hàm

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

4 để phù hợp với đối tượng này với dữ liệu x- và y. Lưu ý rằng chức năng

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

4 cần được nhập từ gói phụ

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

8:\(y = ae^{bx} + c\). This is done by defining it as a lambda function (ie as an object rather than as a command) of a dummy variable \(t\) and using the

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

4 function to fit this object to the x- and y-data. Note that the

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

4 function needs to be imported from the

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

8 sub-package:

from scipy.optimize import curve_fit

# Fit the function a * np.exp(b * t) + c to x and y
popt, pcov = curve_fit(lambda t, a, b, c: a * np.exp(b * t) + c, x, y)

Lưu ý rằng chúng ta cần loại bỏ bất kỳ giá trị nào bằng 0 khỏi dữ liệu y của chúng ta (và giá trị x tương ứng của chúng khỏi dữ liệu x) để hoạt động này, mặc dù không có bất kỳ giá trị nào trong số này trong ví dụ này không liên quan ở đây

Đầu ra đầu tiên,

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

9, là danh sách các giá trị được tối ưu hóa cho các tham số, trong trường hợp của chúng tôi là các hằng số \ (a \), \ (b \) và \ (c \):\(a\), \(b\) and \(c\):

a = popt[0]
b = popt[1]
c = popt[2]

Hãy để xem những gì nó trông như thế nào:

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

0

Điều này có vẻ thực sự tốt, và chúng tôi đã không cần phải cung cấp một phỏng đoán ban đầu! Điều này là do dữ liệu ví dụ chúng tôi đang sử dụng đủ gần với số mũ mà thuật toán tối ưu hóa phía sau

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

4 có thể phù hợp với đường cong mà không vô tình chọn mức tối thiểu cục bộ sai. Điều này won luôn luôn là trường hợp, vì vậy, đây là cách để thực hiện nó với một dự đoán ban đầu được cung cấp:

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

1

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

2

So sánh các phương pháp

Hãy để âm mưu cho cả ba phương thức với nhau bằng cách sử dụng cùng một dữ liệu ví dụ (\ (c = 0 \)) cho mỗi phương pháp:\(c = 0\)) for each:

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

3

Như bạn có thể thấy, phương pháp

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 0
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

# Fit a polynomial of degree 1 (a linear function) to the data
p = np.polyfit(x, np.log(y), 1)

4 đã cho chúng ta xấp xỉ tốt nhất về hành vi theo cấp số nhân thực sự.

Nội suy và ngoại suy (dự báo/dự đoán/ước tính)

Chúng tôi có thể sử dụng đường cong được trang bị để ước tính dữ liệu của chúng tôi sẽ là gì cho các giá trị khác của \ (x \) không có trong bộ dữ liệu thô của chúng tôi: giá trị sẽ ở mức \ (x = 11 \) (nằm ngoài miền của chúng tôi và Do đó, yêu cầu chúng tôi dự báo trong tương lai) hoặc \ (x = 8,5 \) (nằm trong miền của chúng tôi và do đó yêu cầu chúng tôi 'điền vào khoảng cách' trong dữ liệu của chúng tôi)? Để trả lời những câu hỏi này, chúng tôi chỉ cần cắm các giá trị X này làm số vào phương trình của đường cong được trang bị:\(x\) that are not in our raw dataset: what would the value be at \(x=11\) (which is outside our domain and thus requires us to forecast into the future) or \(x = 8.5\) (which is inside our domain and thus requires us to ‘fill in a gap’ in our data)? To answer these questions, we simply plug these x-values as numbers into the equation of the fitted curve:

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

4

Rõ ràng hơn:

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

5

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

6

Sử dụng một lô thanh

Nếu bạn muốn sử dụng một âm mưu thanh thay vì biểu đồ phân tán:

import numpy as np

# Set a seed for the random number generator so we get the same random numbers each time
np.random.seed(20210706)

# Create fake x-data
x = np.arange(10)
# Create fake y-data
a = 4.5
b = 0.5
c = 50
y = a * np.exp(b * x) + c  # Use the second formulation from above
y = y + np.random.normal(scale=np.sqrt(np.max(y)), size=len(x))  # Add noise

7

⇦ Quay lại