Garis non linier python yang paling cocok

Dalam tutorial Python ini, kita akan belajar Bagaimana Scikit belajar non-linier bekerja dan kita juga akan membahas berbagai contoh terkait dengan Scikit belajar non-linier. Selain itu, kami akan membahas topik ini

• Scikit belajar non-linear
• Scikit mempelajari regresi non-linier
• Scikit mempelajari contoh regresi non-linier
• Scikit mempelajari SVM non-linier
• Scikit mempelajari model non-linier
• Scikit mempelajari classifier non-linear
• Scikit mempelajari reduksi dimensi non-linear
• Scikit mempelajari PCA non linier

Sebelum melanjutkan dalam tutorial ini, kami menyarankan Anda untuk membaca What is Scikit Learn in Python

Daftar isi

Scikit belajar non-linear

Kode

Dalam kode berikut, kami akan mengimpor beberapa perpustakaan tempat kami dapat membuat scikit belajar non-linear

• x = bilangan. urutkan(5 * angka. acak. rand(42, 1), axis=0) digunakan untuk menghasilkan data yang sama
• y[. 5] += 3 * (0. 5 – nomor. acak. rand(9)) digunakan untuk menambahkan noise ke target
• svrrbf = SVR(kernel=”rbf”, C=100, gamma=0. 1, epsilon=0. 1) digunakan untuk itu model regresi
• lw = 2 digunakan untuk melihat hasilnya
• ara, sumbu = petak. subplots(nrows=1, ncols=3, figsize=(15, 10), sharey=True) digunakan untuk memplot gambar dan sumbu pada layar
• kapak[ix]. plot(x,svr. cocok(x,y). prediksi(x),color=model_color[ix],lw=lw,label{}model”. format(kernel_label[ix]),) digunakan untuk memplot sumbu di layar
• kapak[ix]. pencar(x[svr. dukungan_],y[svr. support_],facecolor=”none”,edgecolor=model_color[ix],s=50,label=”{} vektor dukungan”. format(kernel_label[ix]),) digunakan untuk memplot plot pencar di layar
• ara. teks(0. 5, 0. 04, “data”, ha=”center”, va=”center”) digunakan untuk text to figure

import numpy as num
from sklearn.svm import SVR
import matplotlib.pyplot as plot

x = num.sort(5 * num.random.rand(42, 1), axis=0)
y = num.sin(x).ravel()
y[::5] += 3 * (0.5 - num.random.rand(9))

svrrbf = SVR(kernel="rbf", C=100, gamma=0.1, epsilon=0.1)

lw = 2

svrs = [svrrbf]
kernel_label = ["RBF"]
model_color = ["m"]

fig, axes = plot.subplots(nrows=1, ncols=3, figsize=(15, 10), sharey=True)
for ix, svr in enumerate(svrs):
    axes[ix].plot(
        x,
        svr.fit(x, y).predict(x),
        color=model_color[ix],
        lw=lw,
        label="{} model".format(kernel_label[ix]),
    )
    axes[ix].scatter(
        x[svr.support_],
        y[svr.support_],
        facecolor="none",
        edgecolor=model_color[ix],
        s=50,
        label="{} support vectors".format(kernel_label[ix]),
    )
    axes[ix].scatter(
        x[num.setdiff1d(num.arange(len(x)), svr.support_)],
        y[num.setdiff1d(num.arange(len(x)), svr.support_)],
        facecolor="none",
        edgecolor="r",
        s=50,
        label="other training data",
    )
    
fig.text(0.5, 0.04, "data", ha="center", va="center")
fig.text(0.06, 0.5, "target", ha="center", va="center", rotation="vertical")
plot.show()

Keluaran

Setelah menjalankan kode di atas, kita mendapatkan keluaran berikut di mana kita dapat melihat bahwa data non-linier ditampilkan di layar

Membaca. Regresi logistik Scikit-pelajari

Scikit mempelajari regresi non-linier

Pada bagian ini, kita akan belajar bagaimana Scikit mempelajari regresi non-linear bekerja dengan python

• Regresi didefinisikan sebagai teknik pembelajaran mesin yang diawasi. Ada dua jenis algoritma regresi Linear dan non-linear
• Di sini kita dapat menggunakan teknik regresi non-linear yang digunakan untuk menggambarkan non-linearitas dan parameternya tergantung pada satu atau lebih variabel independen.

Kode

Dalam kode berikut, kita akan mempelajari beberapa pustaka tempat kita dapat membuat model regresi non-linear

• df = pds. read_csv(“regresichina_gdp. csv”) digunakan untuk membaca file yang kita impor
• merencanakan. figure(figsize=(8,5)) digunakan untuk memplot gambar
• x_data, y_data = (df[“Tahun”]. nilai, df[“Nilai”]. nilai) digunakan untuk menggambarkan nilai dan tahun
• merencanakan. plot(x_data, y_data, 'ro') digunakan untuk memplot data x dan data y
• merencanakan. ylabel('GDP') digunakan untuk memplot label y
• merencanakan. xlabel('Tahun') digunakan untuk memplot label x

import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
df = pds.read_csv("regressionchina_gdp.csv")
df.head(10)
plot.figure(figsize=(8,5))
x_data, y_data = (df["Year"].values, df["Value"].values)
plot.plot(x_data, y_data, 'ro')
plot.ylabel('GDP')
plot.xlabel('Year')
plot.show()

Dalam kode berikut, kami memilih model untuk menggambar regresi linier di layar

• merencanakan. plot(x,y) digunakan untuk memplot x dan y di layar
• merencanakan. ylabel('Dependent Variable') digunakan untuk memplot label y di layar
• merencanakan. xlabel('Variabel Independen') digunakan untuk memplot ylabel di layar

x = np.arange(-5.0, 5.0, 0.1)
y = 1.0 / (1.0 + np.exp(-x))
plot.plot(x,y) 
plot.ylabel('Dependent Variable')
plot.xlabel('Indepdendent Variable')
plot.show()

Di sini, kita dapat menggunakan fungsi logistik untuk membangun model non-linear kita

Sekarang, plot. plot(x_data, Y_pred*15000000000000. ) digunakan untuk memplot posisi awal terhadap titik data

def sigmoid(x, Beta_1, Beta_2):
     y = 1 / (1 + np.exp(-Beta_1*(x-Beta_2)))
     return y
beta1 = 0.10
beta2 = 1990.0
#logistic function
Y_pred = sigmoid(x_data, beta1 , beta2)

plot.plot(x_data, Y_pred*15000000000000.)
plot.plot(x_data, y_data, 'ro')

Di sini kita dapat menormalkan data kita agar sesuai dengan kurva

• merencanakan. figure(figsize=(8,5)) digunakan untuk memplot gambar di layar
• merencanakan. plot(xdata, ydata, 'ro', label='data') digunakan untuk memplot ydata dan xdata di layar
• merencanakan. plot(x,y, lebar garis=3. 0, label='fit') digunakan untuk memplot garis yang sesuai pada layar

xdata =x_data/max(x_data)
ydata =y_data/max(y_data)
from scipy.optimize import curve_fit
popt, pcov = curve_fit(sigmoid, xdata, ydata)
# Now we plot our resulting regression model.
x = np.linspace(1960, 2015, 55)
x = x/max(x)
plot.figure(figsize=(8,5))
y = sigmoid(x, *popt)
plot.plot(xdata, ydata, 'ro', label='data')
plot.plot(x,y, linewidth=3.0, label='fit')
plot.legend(loc='best')
plot.ylabel('GDP')
plot.xlabel('Year')
plot.show()

Setelah menjalankan kode di atas, kita mendapatkan output berikut di mana kita dapat melihat bahwa garis paling cocok non-linier diplot di layar

Membaca. Scikit mempelajari Pohon Keputusan

Scikit mempelajari contoh regresi non-linier

Pada bagian ini, kita akan belajar tentang bagaimana Scikit mempelajari contoh regresi non-linier bekerja dengan python

Regresi non linier didefinisikan sebagai regresi kuadrat yang membangun hubungan antara variabel dependen dan independen. Data ini ditunjukkan oleh garis kurva

Kode

Dalam kode berikut, kami akan mengimpor beberapa pustaka tempat contoh regresi non-linier bekerja

• df = pds. read_csv(“regresichina_gdp. csv”) digunakan untuk membaca file csv yang sedang kita load
• y = 1 / (1 + np. exp(-Beta_1*(x-Beta_2))) digunakan untuk mendefinisikan fungsi sigmoid
• ypred = sigmoid(x_data, beta1, beta2) digunakan sebagai fungsi logistik
• merencanakan. plot(x_data, ypred * 16000000000000. ) digunakan untuk memplot prediksi awal terhadap titik data
• merencanakan. plot(x_data, y_data, 'go') digunakan untuk memplot x_data dan y_data pada grafik

import numpy as num
import pandas as pds
import matplotlib.pyplot as plot

     
df = pds.read_csv("regressionchina_gdp.csv")
 
def sigmoid(x, Beta_1, Beta_2):
     y = 1 / (1 + np.exp(-Beta_1*(x-Beta_2)))
     return y
     
beta1 = 0.10
beta2 = 1990.0
 
ypred = sigmoid(x_data, beta1, beta2)

plot.plot(x_data, ypred * 16000000000000.)
plot.plot(x_data, y_data, 'go')

Keluaran

Setelah menjalankan kode di atas, kita mendapatkan keluaran berikut di mana kita dapat melihat bahwa garis kurva menunjukkan ketidaklinieran grafik

Membaca. Scikit mempelajari Hierarchical Clustering

Scikit mempelajari SVM non-linier

Pada bagian ini, kita akan belajar bagaimana scikit mempelajari SVM non-linier bekerja dengan python

• SVM non-linear adalah singkatan dari support vector machine yang merupakan algoritma pembelajaran mesin terawasi yang digunakan sebagai klasifikasi dan regresi keduanya
• Seperti yang kita ketahui non-linear didefinisikan sebagai hubungan antara variabel dependen dan independen dan itu membuat garis melengkung untuk menggambarkan model.

Kode

Pada kode berikut, kita akan mengimpor beberapa pustaka yang darinya kita dapat membuat model SVM non-linear

• x = bilangan. acak. randn(350, 2) digunakan untuk menghasilkan angka acak
• pengklasifikasi = svm. NuSVC() digunakan untuk membuat svm classifier
• penggolong. fit(x, Y) digunakan agar sesuai dengan model
• Z = pengklasifikasi. fungsi_keputusan(np. c_[xx. bersenang-senang(), yy. ravel()]) digunakan untuk memplot fungsi keputusan dari setiap titik data pada grid
• merencanakan. imshow(Z, interpolasi=’terdekat’,luas=(xx. min(), xx. maks(), yy. min(), yy. max()), aspek = 'otomatis', asal = 'lebih rendah', cmap = plot. cm. PuOr_r) digunakan untuk memplot grafik di layar
• merencanakan. sebar(x[. , 0], x[. , 1], s=35, c=Y, cmap=plot. cm. Berpasangan) digunakan untuk memplot titik pencar di grid

import numpy as num
import matplotlib.pyplot as plot
from sklearn import svm

xx, yy = num.meshgrid(num.linspace(-3, 3, 500),
                     num.linspace(-3, 3, 500))
num.random.seed(0)
x = num.random.randn(350, 2)
Y = num.logical_xor(x[:, 0] > 0, x[:, 1] > 0)


classifier = svm.NuSVC()
classifier.fit(x, Y)

Z = classifier.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plot.imshow(Z, interpolation='nearest',
           extent=(xx.min(), xx.max(), yy.min(), yy.max()), aspect='auto',
           origin='lower', cmap=plot.cm.PuOr_r)
contours = plot.contour(xx, yy, Z, levels=[0], linewidths=2,
                       linetypes='--')
plot.scatter(x[:, 0], x[:, 1], s=35, c=Y, cmap=plot.cm.Paired)
plot.xticks(())
plot.yticks(())
plot.axis([-3, 3, -3, 3])
plot.show()

Keluaran

Setelah menjalankan kode di atas, kita mendapatkan output berikut di mana kita dapat melihat bahwa grafik SVM Scikit learn non-linear diplot di layar

Membaca. Scikit mempelajari Model Markov Tersembunyi

Scikit mempelajari model non-linier

Pada bagian ini, kita akan belajar tentang bagaimana Scikit mempelajari model non-linear bekerja dengan python

• Model non-linear mendefinisikan hubungan non-linear antara data dan parameternya tergantung pada satu atau lebih variabel independen
• Non-linearitas ditunjukkan di mana titik data membuat garis melengkung dari sini non-linearitas data terbukti

Kode

Dalam kode berikut, kita akan mengimpor beberapa pustaka yang darinya kita dapat melihat bahwa model non-linier berfungsi

• rentang = angka. acak. RandomState(0) digunakan untuk menghasilkan keadaan acak
• lendata = (datamax – datamin) digunakan untuk mendapatkan panjang data
• data = jumlah. mengurutkan(rentang. rand(nsample) * lendata – lendata / 2) digunakan untuk mengurutkan data untuk membuat plotting rasy
• target = data** 3 – 0. 6 * data ** 2 + noise digunakan untuk membuat target
• full_data = pds. DataFrame({“fitur masukan”. data, "target". target}) digunakan untuk mendapatkan data lengkap dari kerangka data
• nonlineardata = sns. scatterplot(data=data_lengkap, x=”fitur masukan”, y=”target”, warna=”biru”, alfa=0. 5) digunakan untuk memplot titik pencar pada grafik

import numpy as num

range = num.random.RandomState(0)

nsample = 100
datamax, datamin = 1.5, -1.5
lendata = (datamax - datamin)

data = num.sort(range.rand(nsample) * lendata - lendata / 2)
noise = range.randn(nsample) * .3
target = data ** 3 - 0.6 * data ** 2 + noise
import pandas as pds

full_data = pds.DataFrame({"input feature": data, "target": target})
import seaborn as sns

nonlineardata = sns.scatterplot(data=full_data, x="input feature", y="target",
color="blue", alpha=0.5)

Keluaran

Setelah menjalankan kode di atas, kita mendapatkan output berikut di mana kita dapat melihat bahwa model non-linier pembelajaran Scikit diplot di layar

Membaca. Scikit mempelajari Regresi Ridge

Scikit mempelajari classifier non-linear

Pada bagian ini, kita akan belajar tentang cara kerja classifier non-linear Scikit learn di python

Pengklasifikasi non-linear didefinisikan sebagai proses klasifikasi yang digunakan untuk menggambarkan non-linearitas dan parameternya tergantung pada satu atau lebih variabel independen.

kode

Dalam kode berikut, kami akan mengimpor beberapa pustaka tempat kami dapat membuat pengklasifikasi non-linear

• x = x. copy() digunakan untuk menyalin data
• x = bilangan. acak. normal(size=(n, 2)) digunakan untuk menghasilkan angka acak
• xtrain, xtest, ytrain, ytest = train_test_split(x, y, random_state=0, test_size=0. 5) digunakan untuk membagi dataset menjadi data latih dan data uji
• merencanakan. figure(figsize=(5,5)) digunakan untuk memplot gambar di layar
• merencanakan. pencar(xtrain[. ,0], xtrain[. ,1], c=ytrain, edgecolors=’r’);

import numpy as num
import matplotlib.pyplot as plot

from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

%config InlineBackend.figure_format = 'svg' 
plot.style.use('bmh')
plot.rcParams['image.cmap'] = 'Paired_r'
num.random.seed(5)

def f(x):
    x = x.copy()
    x[:,0] -= 0.4
    x[:,1] += 0.2
    return 1.1*x[:,0]**2 + 0.3*x[:,1]**2 - 0.6*x[:,0]*x[:,1]

def makedata():
    n = 800
    x = num.random.normal(size=(n, 2))
    y = f(x) < 0.5
    x += num.random.normal(size=(n,2), scale=0.2)
    return x, y

x, y = makedata()

xtrain, xtest, ytrain, ytest = train_test_split(x, y, random_state=0, test_size=0.5)

plot.figure(figsize=(5,5))
plot.scatter(xtrain[:,0], xtrain[:,1], c=ytrain, edgecolors='r');

Dalam kode di bawah ini kita akan memplot batas-batas classifier

• xx, yy = bil. meshgrid (bil. arange(x_min, x_max, h),num. arange(y_min, y_max, h)) digunakan untuk membuat meshgridon layar
• Z = pengklasifikasi. memprediksi (bil. c_[xx. bersenang-senang(), yy. ravel()]) digunakan untuk memprediksi classifier
• merencanakan. figure(figsize=(5,5)) digunakan untuk memplot classifier di layar
• merencanakan. sebar(X[. ,0], X[. ,1], c=Y, edgecolors=’r’);
• plot_boundary(classifier, xtrain, ytrain) digunakan untuk memplot batas classifier
• akurasi_skor(ytest, classifier. predict(xtest)) digunakan untuk memprediksi skor akurasi

def plot_boundary(classifier, X, Y):
    h = 0.02
    x_min, x_max = X[:,0].min() - 10*h, X[:,0].max() + 10*h
    y_min, y_max = X[:,1].min() - 10*h, X[:,1].max() + 10*h
    xx, yy = num.meshgrid(num.arange(x_min, x_max, h),
                         num.arange(y_min, y_max, h))
    Z = classifier.predict(num.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)

    plot.figure(figsize=(5,5))
    plot.contourf(xx, yy, Z, alpha=0.25)
    plot.contour(xx, yy, Z, colors='r', linewidths=0.7)
    plot.scatter(X[:,0], X[:,1], c=Y, edgecolors='r');
    from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression().fit(xtrain, ytrain)

plot_boundary(classifier, xtrain, ytrain)
accuracy_score(ytest, classifier.predict(xtest))

Membaca. Scikit mempelajari Regresi Linear

Scikit mempelajari reduksi dimensi non-linear

Pada bagian ini, kita akan belajar tentang bagaimana Scikit mempelajari reduksi dimensi non-linier bekerja dengan python

Pengurangan dimensi Non-Linear digunakan untuk mengurangi jumlah item dalam kumpulan data tanpa ada penurunan informasi

kode

Dalam kode berikut, kami akan mengimpor beberapa perpustakaan tempat kami dapat membuat scikit mempelajari pengurangan dimensi non-linear

• peringatan. filterwarnings('ignore') digunakan untuk memberikan peringatan filter
• x, y = make_s_curve(n_samples=100) digunakan untuk membuat kurva
• digit = load_digits(n_class=6) digunakan untuk memuat digit
• merencanakan. figure(figsize=(12,8)) digunakan untuk memplot gambar di layar
• sumbu = petak. axes(projection='3d') digunakan untuk memplot sumbu di layar
• sumbu. pencar3D(x[. , 0], x[. , 1], x[. , 2], c=y) digunakan untuk memplot pencar pada grafik

import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
df = pds.read_csv("regressionchina_gdp.csv")
df.head(10)
plot.figure(figsize=(8,5))
x_data, y_data = (df["Year"].values, df["Value"].values)
plot.plot(x_data, y_data, 'ro')
plot.ylabel('GDP')
plot.xlabel('Year')
plot.show()

Keluaran

Setelah menjalankan kode di atas, kita mendapatkan keluaran berikut di mana kita dapat melihat pengurangan dimensi non-linear

Membaca. Scikit mempelajari Penyetelan Hyperparameter

Scikit mempelajari PCA non-linier

• Dalam hal ini, kami menjelaskan perbedaannya dengan menggunakan contoh di mana di satu sisi KernalPCA dapat menemukan proyeksi data yang memisahkannya secara linear, dan ini tidak terjadi pada kasus PCA
• PCA adalah singkatan dari Analisis Komponen Utama. Dalam proses ini, digunakan dalam proses komponen utama. Ini juga merupakan metode pengurangan dimensi yang membantu mengurangi dimensi
• Sekarang, kami menjelaskan contoh PCA non-linier dengan menjelaskan perbedaan PCA vs KernalPCA menggunakan data proyeksi

Kode

Dalam kode berikut, kami memberi tahu keuntungan menggunakan kernel saat memproyeksikan data menggunakan PCA

Dalam blok kode ini, kami membuat dua kumpulan data bersarang

import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
df = pds.read_csv("regressionchina_gdp.csv")
df.head(10)
plot.figure(figsize=(8,5))
x_data, y_data = (df["Year"].values, df["Value"].values)
plot.plot(x_data, y_data, 'ro')
plot.ylabel('GDP')
plot.xlabel('Year')
plot.show()

Keluaran

Setelah menjalankan kode berikut, kami mendapatkan output berikut di mana kami dapat memiliki tampilan cepat dari dua set data yang dihasilkan bersarang

• Salah satunya adalah dataset pelatihan dan yang lainnya adalah dataset pengujian
• Sampel dari setiap kelas tidak dapat dipisahkan secara linier karena tidak ada garis lurus yang dipisahkan secara linier yang dapat memisahkan dataset dalam dengan dataset luar

Dalam blok kode ini, kami menggunakan PCA dengan dan tanpa kernel untuk melihat efek apa yang ada saat menggunakan kernel

• Kernel yang digunakan dalam hal ini adalah kernel Radial basis function (RBF).
• asal_data_ax1. set_ylabel() digunakan untuk memberi label pada sumbu y untuk data Testing
• asal_data_ax1. set_xlabel() digunakan untuk memberi label pada sumbu x untuk data Testing
• asal_data_ax1. set_title() digunakan untuk memberi label pada Judul grafik untuk data Pengujian
• pca_proj_ax1. set_ylabel() digunakan untuk memberi label pada sumbu y untuk PCA
• pca_proj_ax1. set_xlabel() digunakan untuk memberi label pada sumbu x untuk PCA
• pca_proj_ax1. set_title() digunakan untuk memberikan judul grafik untuk PCA

import numpy as num
import pandas as pds
import matplotlib.pyplot as plot
df = pds.read_csv("regressionchina_gdp.csv")
df.head(10)
plot.figure(figsize=(8,5))
x_data, y_data = (df["Year"].values, df["Value"].values)
plot.plot(x_data, y_data, 'ro')
plot.ylabel('GDP')
plot.xlabel('Year')
plot.show()

Keluaran

Setelah menjalankan kode berikut, kita mendapatkan output berikut dimana kita bisa melihat perbandingan data Pengujian, Proyeksi data pengujian menggunakan PCA, dan Proyeksi data pengujian menggunakan KernelPCA

• Mari kita merevisi bahwa PCA mengubah data secara linier yang berarti bahwa sistem yang diatur akan dipusatkan, diskalakan ulang pada semua komponen sehubungan dengan variansnya, dan akhirnya diputar
• Melihat output di bawah ini kita dapat melihat pada struktur tengah bahwa tidak ada perubahan pada struktur yang terkait dengan penskalaan
• PCA kernel memungkinkan membuat proyeksi non-linear
• Di sini, dengan menggunakan kernel RBF, kami berharap bahwa proyeksi akan membuka kumpulan data sambil menjaga jarak relatif pasangan titik data yang berdekatan satu sama lain di ruang asli
• Perbedaan tersebut dapat kita lihat dan amati pada struktur KernelPCA yang berada di sisi kanan

Anda mungkin juga ingin membaca tutorial tentang pembelajaran Scikit

• Scikit mempelajari Data Terpisah
• Scikit mempelajari Algoritma Genetika
• Scikit belajar Tutorial Klasifikasi
• Scikit pelajari hidden_layer_sizes
• Scikit belajar Tutorial Gaussian
• Scikit mempelajari Validasi Silang

Jadi, dalam tutorial ini kita membahas Scikit belajar Non-linier dan kita juga telah membahas berbagai contoh terkait penerapannya. Berikut adalah daftar contoh yang telah kami bahas

• Scikit belajar non-linear
• Scikit mempelajari regresi non-linier
• Scikit mempelajari contoh regresi non-linier
• Scikit mempelajari SVM non-linier
• Scikit mempelajari model non-linier
• Scikit mempelajari classifier non-linear
• Scikit mempelajari reduksi dimensi non-linear
• Scikit mempelajari PCA non linier

Bijay Kumar

Python adalah salah satu bahasa paling populer di Amerika Serikat. Saya telah bekerja dengan Python untuk waktu yang lama dan saya memiliki keahlian dalam bekerja dengan berbagai perpustakaan di Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, dll… Saya memiliki pengalaman dalam bekerja dengan berbagai klien . Lihat profil saya

Bagaimana Anda menjalankan regresi non linier dengan Python?

Apa itu Lmfit dengan Python?

Model mana yang terbaik untuk data non linier?