আমার কাছে ডেটার একটি সেট রয়েছে এবং আমি তুলনা করতে চাই যে লাইনটি এটি সর্বোত্তমভাবে বর্ণনা করে (বিভিন্ন অর্ডার, ক্ষতিকারক বা লগারিদমিকের বহুপদী)।
আমি পাইথন এবং নম্পি ব্যবহার করি এবং বহুমুখী ফিটিংয়ের জন্য একটি ফাংশন রয়েছে polyfit() । তবে আমি ক্ষতিকারক এবং লগারিদমিক ফিটিংয়ের জন্য এই জাতীয় কোনও কার্যকারিতা পাইনি।
কোন আছে? না হলে কীভাবে সমাধান করা যায়?
উত্তর:
ঝুলানো জন্য Y = একটি + + বি লগ এক্স , ঠিক হইয়া Y বিরুদ্ধে (লগ এক্স )।
>>> x = numpy.array([1, 7, 20, 50, 79])
>>> y = numpy.array([10, 19, 30, 35, 51])
>>> numpy.polyfit(numpy.log(x), y, 1)
array([ 8.46295607, 6.61867463])
# y ≈ 8.46 log(x) + 6.62ঝুলানো জন্য Y = Ae বিভাগ BX গ্রহণ উভয় পার্শ্ব লগারিদম লগ দেয় Y = log একটি + + bx । সুতরাং হইয়া (লগ Y ) বিরুদ্ধে এক্স ।
লক্ষ্য করুন ঝুলানো (লগ Y ) হিসাবে যদি তা না হয় রৈখিক ছোট মান জোর দেওয়া হবে Y , বড় জন্য বড় বিচ্যুতি ঘটাচ্ছে Y । এ কারণে যে polyfit(রৈখিক রিগ্রেশনের) Σ কমানোর করে কাজ করে আমি (Δ ওয়াই ) 2 = Σ আমি ( ওয়াই আমি - Y আমি ) 2 । যখন Y i = লগ y আমি , অবশিষ্টাংশগুলি Δ Y i = Δ (লগ y আমি ) ≈ Δ y i / | y i | এমনকি যদিpolyfitলার্জ ওয়াইয়ের জন্য খুব খারাপ সিদ্ধান্ত নিয়েছে , "বিভাজন দ্বারা | y |" ফ্যাক্টর এটির জন্য ক্ষতিপূরণ দেবে, যার ফলে polyfitছোট মূল্যবোধের পক্ষে হবে ।
প্রতিটি প্রবেশকে y এর সমানুপাতিক "ওজন" দিয়ে এটিকে হ্রাস করা যেতে পারে । polyfitমূলশব্দ wআর্গুমেন্টের মাধ্যমে ওজনযুক্ত-সর্বনিম্ন-স্কোয়ার সমর্থন করে ।
>>> x = numpy.array([10, 19, 30, 35, 51])
>>> y = numpy.array([1, 7, 20, 50, 79])
>>> numpy.polyfit(x, numpy.log(y), 1)
array([ 0.10502711, -0.40116352])
# y ≈ exp(-0.401) * exp(0.105 * x) = 0.670 * exp(0.105 * x)
# (^ biased towards small values)
>>> numpy.polyfit(x, numpy.log(y), 1, w=numpy.sqrt(y))
array([ 0.06009446, 1.41648096])
# y ≈ exp(1.42) * exp(0.0601 * x) = 4.12 * exp(0.0601 * x)
# (^ not so biased)নোট করুন যে এক্সেল, লিব্রেঅফিস এবং সর্বাধিক বৈজ্ঞানিক ক্যালকুলেটরগুলি ঘনিষ্ঠভাবে রিগ্রেশন / ট্রেন্ড লাইনের জন্য সাধারণত অদূরিত (পক্ষপাতমূলক) সূত্র ব্যবহার করে। যদি আপনি চান যে আপনার ফলাফলগুলি এই প্ল্যাটফর্মগুলির সাথে সামঞ্জস্যপূর্ণ হয়, তবে আরও ভাল ফলাফল সরবরাহ করা হলেও ওজনগুলি অন্তর্ভুক্ত করবেন না।
এখন, আপনি স্কিপি ব্যবহার করতে পারেন, আপনি scipy.optimize.curve_fitকোনও রূপান্তর ছাড়াই কোনও মডেল ফিট করতে ব্যবহার করতে পারেন।
জন্য Y = একটি + + বি লগ x ফলাফলের রূপান্তর পদ্ধতি হিসাবে একই:
>>> x = numpy.array([1, 7, 20, 50, 79])
>>> y = numpy.array([10, 19, 30, 35, 51])
>>> scipy.optimize.curve_fit(lambda t,a,b: a+b*numpy.log(t), x, y)
(array([ 6.61867467, 8.46295606]),
array([[ 28.15948002, -7.89609542],
[ -7.89609542, 2.9857172 ]]))
# y ≈ 6.62 + 8.46 log(x)জন্য Y = Ae বিভাগ BX তবে, আমরা একটি ভাল হইয়া যেহেতু এটি Δ (লগ নির্ণয় পেতে পারেন Y ) সরাসরি। তবে আমাদের একটি প্রাথমিক অনুমান সরবরাহ করা দরকার যাতে curve_fitকাঙ্ক্ষিত স্থানীয় সর্বনিম্ন পৌঁছাতে পারে।
>>> x = numpy.array([10, 19, 30, 35, 51])
>>> y = numpy.array([1, 7, 20, 50, 79])
>>> scipy.optimize.curve_fit(lambda t,a,b: a*numpy.exp(b*t), x, y)
(array([ 5.60728326e-21, 9.99993501e-01]),
array([[ 4.14809412e-27, -1.45078961e-08],
[ -1.45078961e-08, 5.07411462e+10]]))
# oops, definitely wrong.
>>> scipy.optimize.curve_fit(lambda t,a,b: a*numpy.exp(b*t), x, y, p0=(4, 0.1))
(array([ 4.88003249, 0.05531256]),
array([[ 1.01261314e+01, -4.31940132e-02],
[ -4.31940132e-02, 1.91188656e-04]]))
# y ≈ 4.88 exp(0.0553 x). much better.
yছোট সেগুলি কৃত্রিমভাবে ওভারওয়েট করা হবে। ফাংশনটি সংজ্ঞায়িত করা ভাল (লিনিয়ার, লগ রূপান্তর নয়) এবং একটি কার্ভ ফিটার বা মিনিমাইজার ব্যবহার করা।
আপনি যে কোনও ফাংশন curve_fitথেকে যেটি ব্যবহার করতে চান তাতে কোনও ডেটার সেটও ফিট করতে পারেন scipy.optimize। উদাহরণস্বরূপ, আপনি যদি কোনও ক্ষতিকারক ফাংশন ফিট করতে চান ( ডকুমেন্টেশন থেকে ):
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
def func(x, a, b, c):
return a * np.exp(-b * x) + c
x = np.linspace(0,4,50)
y = func(x, 2.5, 1.3, 0.5)
yn = y + 0.2*np.random.normal(size=len(x))
popt, pcov = curve_fit(func, x, yn)এবং তারপরে আপনি যদি চক্রান্ত করতে চান তবে আপনি এটি করতে পারেন:
plt.figure()
plt.plot(x, yn, 'ko', label="Original Noised Data")
plt.plot(x, func(x, *popt), 'r-', label="Fitted Curve")
plt.legend()
plt.show()(দ্রষ্টব্য: *সামনে poptযখন আপনি মধ্যে পদ আউট প্রসারিত হবে প্লটে বিভক্ত a, bএবং cযে func। আশা করা হয়)
a, bএবং c?
আমার এটির সাথে কিছুটা সমস্যা হচ্ছিল তাই আমাকে খুব স্পষ্ট হতে দিন যাতে আমার মতো নুবু বুঝতে পারে।
বলুন যে আমাদের কাছে একটি ডেটা ফাইল বা এর মতো কিছু রয়েছে something
# -*- coding: utf-8 -*-
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
import numpy as np
import sympy as sym
"""
Generate some data, let's imagine that you already have this.
"""
x = np.linspace(0, 3, 50)
y = np.exp(x)
"""
Plot your data
"""
plt.plot(x, y, 'ro',label="Original Data")
"""
brutal force to avoid errors
"""
x = np.array(x, dtype=float) #transform your data in a numpy array of floats
y = np.array(y, dtype=float) #so the curve_fit can work
"""
create a function to fit with your data. a, b, c and d are the coefficients
that curve_fit will calculate for you.
In this part you need to guess and/or use mathematical knowledge to find
a function that resembles your data
"""
def func(x, a, b, c, d):
return a*x**3 + b*x**2 +c*x + d
"""
make the curve_fit
"""
popt, pcov = curve_fit(func, x, y)
"""
The result is:
popt[0] = a , popt[1] = b, popt[2] = c and popt[3] = d of the function,
so f(x) = popt[0]*x**3 + popt[1]*x**2 + popt[2]*x + popt[3].
"""
print "a = %s , b = %s, c = %s, d = %s" % (popt[0], popt[1], popt[2], popt[3])
"""
Use sympy to generate the latex sintax of the function
"""
xs = sym.Symbol('\lambda')
tex = sym.latex(func(xs,*popt)).replace('$', '')
plt.title(r'$f(\lambda)= %s$' %(tex),fontsize=16)
"""
Print the coefficients and plot the funcion.
"""
plt.plot(x, func(x, *popt), label="Fitted Curve") #same as line above \/
#plt.plot(x, popt[0]*x**3 + popt[1]*x**2 + popt[2]*x + popt[3], label="Fitted Curve")
plt.legend(loc='upper left')
plt.show()ফলাফল: a = 0.849195983017, খ = -1.18101681765, সি = 2.24061176543, ডি = 0.816643894816
y = [np.exp(i) for i in x]খুব ধীর; কারণ লিখতে পারার কারণেই নিম্পটি তৈরি হয়েছিল y=np.exp(x)। এছাড়াও, এই প্রতিস্থাপনের সাহায্যে আপনি আপনার পাশবিক বাহিনী বিভাগ থেকে মুক্তি পেতে পারেন। আইপথনে, এমন %timeitযাদু রয়েছে যা থেকে In [27]: %timeit ylist=[exp(i) for i in x] 10000 loops, best of 3: 172 us per loop In [28]: %timeit yarr=exp(x) 100000 loops, best of 3: 2.85 us per loop
x = np.array(x, dtype=float)ধীর তালিকা বোঝার থেকে মুক্তি পেতে আপনাকে সক্ষম করা উচিত।
আমি মনে করি আপনি সর্বদা ব্যবহার করতে পারেন:
np.log --> natural log
np.log10 --> base 10
np.log2 --> base 2IanVS এর উত্তরটি সামান্যভাবে সংশোধন করা হচ্ছে :
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
def func(x, a, b, c):
#return a * np.exp(-b * x) + c
return a * np.log(b * x) + c
x = np.linspace(1,5,50) # changed boundary conditions to avoid division by 0
y = func(x, 2.5, 1.3, 0.5)
yn = y + 0.2*np.random.normal(size=len(x))
popt, pcov = curve_fit(func, x, yn)
plt.figure()
plt.plot(x, yn, 'ko', label="Original Noised Data")
plt.plot(x, func(x, *popt), 'r-', label="Fitted Curve")
plt.legend()
plt.show()নিম্নলিখিত গ্রাফের ফলাফল:
সাধারণ ডেটাতে লিনিয়ারাইজেশন বিকল্পটি এখানে স্কাইকিট শিখার সরঞ্জামগুলি ব্যবহার করে ।
প্রদত্ত
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import FunctionTransformer
np.random.seed(123)# General Functions
def func_exp(x, a, b, c):
"""Return values from a general exponential function."""
return a * np.exp(b * x) + c
def func_log(x, a, b, c):
"""Return values from a general log function."""
return a * np.log(b * x) + c
# Helper
def generate_data(func, *args, jitter=0):
"""Return a tuple of arrays with random data along a general function."""
xs = np.linspace(1, 5, 50)
ys = func(xs, *args)
noise = jitter * np.random.normal(size=len(xs)) + jitter
xs = xs.reshape(-1, 1) # xs[:, np.newaxis]
ys = (ys + noise).reshape(-1, 1)
return xs, ystransformer = FunctionTransformer(np.log, validate=True)কোড
তাত্পর্যপূর্ণ ডেটা ফিট করুন
# Data
x_samp, y_samp = generate_data(func_exp, 2.5, 1.2, 0.7, jitter=3)
y_trans = transformer.fit_transform(y_samp) # 1
# Regression
regressor = LinearRegression()
results = regressor.fit(x_samp, y_trans) # 2
model = results.predict
y_fit = model(x_samp)
# Visualization
plt.scatter(x_samp, y_samp)
plt.plot(x_samp, np.exp(y_fit), "k--", label="Fit") # 3
plt.title("Exponential Fit")
ফিট লগ ডেটা
# Data
x_samp, y_samp = generate_data(func_log, 2.5, 1.2, 0.7, jitter=0.15)
x_trans = transformer.fit_transform(x_samp) # 1
# Regression
regressor = LinearRegression()
results = regressor.fit(x_trans, y_samp) # 2
model = results.predict
y_fit = model(x_trans)
# Visualization
plt.scatter(x_samp, y_samp)
plt.plot(x_samp, y_fit, "k--", label="Fit") # 3
plt.title("Logarithmic Fit")
বিস্তারিত
সাধারণ পদক্ষেপ
x, yবা উভয়)np.exp()) এবং মূল ডেটার সাথে মানানসইধরে নিই আমাদের ডেটা তাত্পর্যপূর্ণ প্রবণতা অনুসরণ করে, একটি সাধারণ সমীকরণ + হতে পারে:
লগ গ্রহণের মাধ্যমে আমরা পরবর্তীকালের সমীকরণকে লিনিয়ারাইজ করতে পারি (যেমন y = ইন্টারসেপ্ট + opeাল * এক্স) :
একটি লিনিয়ারযুক্ত সমীকরণ ++ এবং রিগ্রেশন প্যারামিটার দেওয়া, আমরা গণনা করতে পারি:
Aবাধা মাধ্যমে ( ln(A))Bopeাল মাধ্যমে ( B)লিনিয়ারাইজেশন কৌশলগুলির সংক্ষিপ্তসার
Relationship | Example | General Eqn. | Altered Var. | Linearized Eqn.
-------------|------------|----------------------|----------------|------------------------------------------
Linear | x | y = B * x + C | - | y = C + B * x
Logarithmic | log(x) | y = A * log(B*x) + C | log(x) | y = C + A * (log(B) + log(x))
Exponential | 2**x, e**x | y = A * exp(B*x) + C | log(y) | log(y-C) = log(A) + B * x
Power | x**2 | y = B * x**N + C | log(x), log(y) | log(y-C) = log(B) + N * log(x)+ দ্রষ্টব্য: শব্দটি ছোট এবং সি = 0 হলে লিনিয়ারাইজিং এক্সফোনেনশিয়াল ফাংশনগুলি সর্বোত্তম কাজ করে। সতর্কতার সাথে ব্যবহার করুন.
++, নোট: পরিবর্তনকারী এক্স তথ্য রৈখিকরণ সাহায্য করে যখন সূচকীয় ডেটা, Y তথ্য পরিবর্তনের রৈখিকরণ সাহায্য করে লগ ডেটা।
lmfitউভয় সমস্যার সমাধান করার সময় আমরা এর বৈশিষ্ট্যগুলি প্রদর্শন করি ।
প্রদত্ত
import lmfit
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
np.random.seed(123)# General Functions
def func_log(x, a, b, c):
"""Return values from a general log function."""
return a * np.log(b * x) + c
# Data
x_samp = np.linspace(1, 5, 50)
_noise = np.random.normal(size=len(x_samp), scale=0.06)
y_samp = 2.5 * np.exp(1.2 * x_samp) + 0.7 + _noise
y_samp2 = 2.5 * np.log(1.2 * x_samp) + 0.7 + _noiseকোড
পদ্ধতির 1 - lmfitমডেল
তাত্পর্যপূর্ণ ডেটা ফিট করুন
regressor = lmfit.models.ExponentialModel() # 1
initial_guess = dict(amplitude=1, decay=-1) # 2
results = regressor.fit(y_samp, x=x_samp, **initial_guess)
y_fit = results.best_fit
plt.plot(x_samp, y_samp, "o", label="Data")
plt.plot(x_samp, y_fit, "k--", label="Fit")
plt.legend()
পদ্ধতির 2 - কাস্টম মডেল
ফিট লগ ডেটা
regressor = lmfit.Model(func_log) # 1
initial_guess = dict(a=1, b=.1, c=.1) # 2
results = regressor.fit(y_samp2, x=x_samp, **initial_guess)
y_fit = results.best_fit
plt.plot(x_samp, y_samp2, "o", label="Data")
plt.plot(x_samp, y_fit, "k--", label="Fit")
plt.legend()
বিস্তারিত
আপনি রেজিস্ট্রার অবজেক্ট থেকে অনুমিত প্যারামিটার নির্ধারণ করতে পারেন। উদাহরণ:
regressor.param_names
# ['decay', 'amplitude']দ্রষ্টব্য: নীচে ExponentialModel()একটি ক্ষয় ফাংশন অনুসরণ করা হয় , যা দুটি পরামিতি গ্রহণ করে, যার একটি নেতিবাচক।
আরও দেখুন ExponentialGaussianModel(), যা আরও পরামিতি গ্রহণ করে ।
উল্ফর্যাম জন্য একটি বদ্ধ ফর্ম সমাধান আছে একটি সূচকীয় ঝুলানো । লগারিদমিক এবং শক্তি আইন ফিট করার জন্য তাদেরও একই রকম সমাধান রয়েছে ।
আমি এটি স্কিপির কার্ভ_ফিটের চেয়ে আরও ভাল কাজ করতে পেলাম। এখানে একটি উদাহরণ:
import numpy as np
import matplotlib.pyplot as plt
# Fit the function y = A * exp(B * x) to the data
# returns (A, B)
# From: https://mathworld.wolfram.com/LeastSquaresFittingExponential.html
def fit_exp(xs, ys):
S_x2_y = 0.0
S_y_lny = 0.0
S_x_y = 0.0
S_x_y_lny = 0.0
S_y = 0.0
for (x,y) in zip(xs, ys):
S_x2_y += x * x * y
S_y_lny += y * np.log(y)
S_x_y += x * y
S_x_y_lny += x * y * np.log(y)
S_y += y
#end
a = (S_x2_y * S_y_lny - S_x_y * S_x_y_lny) / (S_y * S_x2_y - S_x_y * S_x_y)
b = (S_y * S_x_y_lny - S_x_y * S_y_lny) / (S_y * S_x2_y - S_x_y * S_x_y)
return (np.exp(a), b)
xs = [33, 34, 35, 36, 37, 38, 39, 40, 41, 42]
ys = [3187, 3545, 4045, 4447, 4872, 5660, 5983, 6254, 6681, 7206]
(A, B) = fit_exp(xs, ys)
plt.figure()
plt.plot(xs, ys, 'o-', label='Raw Data')
plt.plot(xs, [A * np.exp(B *x) for x in xs], 'o-', label='Fit')
plt.title('Exponential Fit Test')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend(loc='best')
plt.tight_layout()
plt.show()