https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
71
FUNKSIONAL BOG'LANISHLARNI KUBIK VA BIKUBIK
SPLAYNLAR YORDAMIDA MODELLASHTIRISH: HISOBLASH
USULLARI VA DASTURIY TA'MINOTINI PYTHON DASTURLASH
TILIDA ISHLAB CHIQISH
Yakubov Jaxongir Rustamjon ogli
Andijon davlat universiteti Axborot texnologiyalari o'qituvchi
Annotatsiya
Ushbu maqolada funksional bog'lanishlarni kubik va bikubik splaynlar
yordamida modellashtirish usullarining keng qamrovli tahlili keltirilgan. Tadqiqot
ayniqsa harorat maydonlarini tahlil qilish va murakkab fizik maydonlarni
modellashtirish bo'yicha yo'naltirilgan. Interpolyatsiya texnikalari, koeffitsientlarni
hisoblash usullari va splayn asosidagi modellashtirish tizimlari uchun dasturiy
ta'minot yaratish yondashuvlari batafsil o'rganilgan.
Bir o'lchovli kubik splaynlar va ikki o'lchovli bikubik splaynlarning nazariy
asoslari hamda ularning harorat taqsimoti va boshqa fizik hodisalarni
modellashtirish sohasidagi amaliy qo'llanilishi tahlil qilingan. Tadqiqotda Furye
bazisli splaynlar, B-splayn metodologiyalari va murakkab maydon modellashtirish
uchun zamonaviy dasturiy yechimlar ham ko'rib chiqilgan.
Eksperimental natijalar bikubik splaynlarning harorat maydonlari va boshqa
fizik parametrlarni yuqori aniqlik bilan ifodalashdagi samaradorligini isbotlaydi.
Ishlab chiqilgan dasturiy ramka fazoviy ma'lumotlar interpolyatsiyasi va maydon
modellashtirish sohasida ishlaydigan tadqiqotchilar va muhandislar uchun
mustahkam vositalar taqdim etadi.
Kalit so'zlar:
kubik splaynlar, bikubik splaynlar, funksional
modellashtirish, interpolyatsiya, harorat maydonlari, B-splaynlar, Furye bazisi,
dasturiy ta'minot
1. Kirish
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
72
Funksional bog'lanishlarni matematik modellashtirish zamonaviy ilm va
texnikaning turli sohalarida muhim ahamiyat kasb etadi. Splayn asosidagi usullar
murakkab funksiyalarni yaqinlashtirish va fizik hodisalarni yuqori aniqlik bilan
modellashtirish uchun kuchli matematik vositalar sifatida keng qo'llanilmoqda.
Bo'lakli ko'phad funksiyalar yordamida silliq egri chiziqlar va sirtlarni ifodalash
qobiliyati splaynlarni hisoblash matematikasi va fizikasidagi interpolyatsiya
hamda yaqinlashtirish vazifalarida ayniqsa samarali qiladi.
Harorat maydonlarini modellashtirish splayn interpolyatsiya texnikalarining
eng muhim va keng tarqalgan qo'llanilish sohalaridan biridir. Turli muhitlarda
harorat taqsimotini tushunish va bashorat qilish issiqlik uzatish tahlili, termal
dizayn optimizatsiyasi, atrof-muhitni monitoring qilish va energiya
samaradorligini baholash kabi ko'plab muhandislik va ilmiy tadqiqot
qo'llanilishlari uchun zarurdir.
An'anaviy ko'phad interpolyatsiya usullari ko'pincha Runge hodisasi kabi
tebranish muammolari va hisoblash beqarorligidan aziyat chekadi, ayniqsa yuqori
darajali ko'phadlar bilan ishlashda bu muammolar kuchayadi. Splayn usullari
uzluksizlik va silliqllik xususiyatlarini saqlaydigan pastroq darajali bo'lakli
ko'phadlardan foydalanish orqali bu cheklovlarni muvaffaqiyatli bartaraf etadi.
Ushbu tadqiqot funksional bog'lanishlarni modellashtirish uchun kubik va
bikubik splayn usullarining keng qamrovli va sistemali tekshirishini taqdim etadi.
Maqolada harorat maydonlarini tahlil qilishda ularning qo'llanilishiga alohida
e'tibor qaratilgan. Nazariy asoslar va amaliy amalga oshirish jihatlarini chuqur
o'rganish orqali splayn asosidagi modellashtirish tizimlari uchun to'liq matematik
va dasturiy ramka yaratilgan.
2.
Funksional
Bog'lanishlarni
Kubik
Splaynlar
Yordamida
Modellashtirish
2.1 Kubik Splaynlarning Nazariy Asoslari
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
73
Kubik splaynlar silliq egri chiziqlarni moslashtirish va interpolyatsiyaning
fundamental yondashuvini ifodalaydi. Ma'lum bir ma'lumotlar to'plami $(x_i, y_i)$
berilgan bo'lsa, bu yerda $i = 0, 1, ..., n$, kubik splayn $S(x)$ har bir ichki tugunda
ikkinchi hosilaga qadar uzluksizlik shartlarini qanoatlantiruvchi bo'lakli kubik
ko'phad sifatida matematik jihatdan aniqlanadi.
Kubik splayn $S(x)$ quyidagi ko'rinishda ifodalanadi:
S(x)=Si(x)=ai+bi(x−xi)+ci(x−xi)2+di(x−xi)3S(x) = S_i(x) = a_i + b_i(x
-
x_i) + c_i(x - x_i)^2 + d_i(x - x_i)^3S(x)=Si(x)=ai+bi
(x−xi
)+ci
(x−xi
)2+di
(x−xi
)3
bu yerda $x \in [x_i, x_{i+1}]$ va $i = 0, 1, ..., n-1$.
Splaynning matematik to'g'riligini ta'minlash uchun quyidagi uzluksizlik
shartlari bajarilishi kerak:
•
Interpolyatsiya sharti:
$S(x_i) = y_i$ (har bir nuqtadan o'tish)
•
Funksiya uzluksizligi:
$S_i(x_{i+1}) = S_{i+1}(x_{i+1})$
•
Birinchi hosila uzluksizligi:
$S'
i(x
{i+1}) = S'
{i+1}(x
{i+1})$
•
Ikkinchi hosila uzluksizligi:
$S''
i(x
{i+1}) = S''
{i+1}(x
{i+1})$
2.2 Koeffitsientlarni Hisoblash Usullari
Splayn koeffitsientlarini aniqlash chiziqli tenglamalar tizimini yechishni o'z
ichiga oladi. Tabiiy kubik splaynlar uchun $S''(x_0) = S''(x_n) = 0$ chegara
shartlari qo'yiladi. Bu Thomas algoritmi yordamida samarali ravishda yechilishi
mumkin bo'lgan uch diagonalli tizimga olib keladi.
Koeffitsientlarni hisoblash jarayoni quyidagi bosqichlarni o'z ichiga oladi:
1.
Uch diagonalli tizimni o'rnatish:
$Ax = b$ matritsa
tenglamasini shakllantirish, bu yerda $A$ uch diagonalli matritsa
2.
Oldinga yo'qotish:
Tizimni yuqori uchburchak shakliga
keltirish
3.
Orqaga almashtirish:
Tugun nuqtalardagi ikkinchi hosilalar
uchun yechim topish
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
74
4.
Koeffitsientlarni aniqlash:
$a_i$, $b_i$, $c_i$, va $d_i$
koeffitsientlarini hisoblash
Hisoblash murakkabligi $O(n)$ ni tashkil etadi, bu usulni katta ma'lumotlar
to'plamlari uchun ham samarali qiladi.
2.3 Interpolyatsiya Xususiyatlari va Xatolik Tahlili
Kubik splaynlar interpolyatsiya uchun bir qancha muhim afzallik
xususiyatlariga ega:
Minimal egrilik xususiyati:
Berilgan nuqtalarni interpolyatsiya qiluvchi
barcha ikki marta differentsiallanuvchi funksiyalar orasida tabiiy kubik splayn
kvadrat ikkinchi hosilaning integralini minimallashtiradi:
∫x0xn[S′′(x)]2dx=min
\int_{x_0}^{x_n} [S''(x)]^2 dx = \
min∫x0
xn
[S′′(x)]2dx=min
Raqamli barqarorlik:
Kubik splaynlar yuqori darajali ko'phad
interpolyatsiyaga nisbatan ajoyib raqamli barqarorlik ko'rsatadi va Runge
hodisasidan himoyalangan.
Yaqinlashish xususiyati:
Etarli darajada silliq funksiyalar uchun kubik
splayn interpolyatsiyasi $O(h^4)$ tezligida yaqinlashadi, bu yerda $h$ tugunlar
orasidagi maksimal masofa.
3. Ikki O'lchovli Maydonlarni Modellashtirish Uchun Bikubik
Splaynlar
3.1 Bikubik Splayn Formulasi va Matematik Asoslari
Bikubik splaynlar kubik splayn kontseptsiyasini ikki o'lchovga kengaytiradi
va ularni harorat taqsimoti kabi fazoviy maydonlarni modellashtirish uchun ideal
qiladi. $(x_i, y_j)$ nuqtalari bilan to'rtburchaklar panjarasi uchun bikubik splayn
sirti $S(x,y)$ quyidagicha aniqlanadi:
S(x,y)=∑i=03∑j=03aijxiyjS(x,y) =
\sum_{i=0}^{3} \sum_{j=0}^{3} a_{ij}
x^i y^jS(x,y)=∑i=03∑j=03
aijxiyj
panjaraning har bir to'rtburchaklar yamog'i ichida.
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
75
Bikubik interpolyatsiya har bir to'rtburchaklar yamog'ining to'rtta burchagida
quyidagi qiymatlarni belgilashni talab qiladi:
•
Funksiya qiymatlari:
$f(x_i, y_j)$
•
X bo'yicha qismli hosilalar:
$f_x(x_i, y_j) = \frac{\partial
f}{\partial x}$
•
Y bo'yicha qismli hosilalar:
$f_y(x_i, y_j) = \frac{\partial
f}{\partial y}$
•
Aralash qismli hosilalar:
$f_{xy}(x_i, y_j) = \frac{\partial^2
f}{\partial x \partial y}$
3.2 Harorat Maydonlarini Modellashtirish Qo'llanilishi
Bikubik splaynlar yordamida harorat maydonlarini modellashtirish bir
qancha muhim afzalliklarni taklif etadi:
Silliq tasviriy ko'rinish:
Bikubik splaynlar yamog' chegaralarida $C^1$
uzluksizligini ta'minlaydi, bu esa silliq harorat gradientlarini kafolatlaydi va fizik
jihatdan mantiqiy taqsimotni yaratadi.
Fizik realizm:
Silliqllik xususiyatlari issiqlik o'tkazuvchanlik tenglamalari
va termodinamik jarayonlar uchun fizik kutishlarga to'liq mos keladi.
Hisoblash samaradorligi:
Bazis funksiyalarning mahalliy qo'llab-
quvvatlashi samarali hisoblash va xotira saqlashni ta'minlaydi, bu esa katta
hajmdagi ma'lumotlar bilan ishlashda muhim.
Moslashuvchan kengaytirish:
Yuqori rezolyutsiya talab qilinadigan muhim
hududlarda panjarani adaptiv ravishda kengaytirish va zichlashtirish imkoniyati
mavjud.
3.3 Chegara Shartlarini Boshqarish
Aniq harorat maydoni modellashtirish uchun chegara shartlarini to'g'ri ko'rib
chiqish muhim ahamiyat kasb etadi:
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
76
Dirichlet chegara shartlari:
Chegara bo'ylab aniq harorat qiymatlari
berilganda qo'llaniladi. Bu shartlar odatda eksperimental o'lchashlar yoki ma'lum
termal shartlar asosida belgilanadi.
Neumann chegara shartlari:
Chegara bo'ylab issiqlik oqimi (harorat
gradienti) ma'lum bo'lganda ishlatiladi. Bu termal izolatsiya yoki ma'lum issiqlik
uzatish koeffitsientlari mavjud bo'lgan hollarda amaliy.
Aralash chegara shartlari:
Real fizik tizimlarda ko'pincha turli turdagi
chegara shartlarining kombinatsiyasi qo'llaniladi.
4. B-Splaynlar va Furye Bazisli Yondashuvlar
4.1 B-Splayn Metodologiyasi
B-splaynlar (Basic splines) splayn interpolyatsiyasining yanada umumiy va
moslashuvchan yondashuvini taqdim etadi. B-splaynlarning asosiy afzalliklari
quyidagilardir:
Mahalliy qo'llab-quvvatlash:
Har bir B-splayn bazis funksiyasi faqat
cheklangan intervalda noldan farqli, bu esa hisoblash samaradorligini oshiradi.
Raqamli barqarorlik:
B-splayn bazisi yaxshi shartlangan bo'lib, raqamli
xatoliklarga kam sezgir.
Moslashuvchanlik:
Turli darajali B-splaynlarni ishlatish orqali kerakli
silliqllik darajasini nazorat qilish mumkin.
4.2 Furye Bazisli Splaynlar
Davriy yoki yarim-davriy harorat taqsimotlarini modellashtirish uchun Furye
bazisli splaynlar alohida samarali:
S(x)=a02+∑n=1N[ancos(nx)+bnsin(nx)]S(x) =
\frac{a_0}{2} +
\sum_{n=1}^{N} [a_n \cos(nx) + b_n \sin(nx)]S(x)=2a0
+∑n=1N
[ancos(nx)+bn
sin(nx)]
Bu yondashuv ayniqsa mavsumiy harorat o'zgarishlari yoki siklik termal
jarayonlarni tahlil qilishda foydali.
5. Dasturiy Ta'minot va Algoritm Realizatsiyasi
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
77
5.1 Dasturiy Ramka Arxitekturasi
Splayn asosidagi modellashtirish tizimlari uchun zamonaviy dasturiy ramka
quyidagi komponentlarni o'z ichiga oladi:
Ma'lumotlar kiritish moduli:
Turli formatdagi (CSV, JSON, XML) harorat
ma'lumotlarini o'qish va preprocessing
Interpolyatsiya yadrosi:
Kubik va bikubik splayn algoritmlarining
optimallashtirilgan realizatsiyasi
Vizualizatsiya moduli:
2D va 3D harorat maydonlarini tasvirlash uchun
grafik interfeys
Export moduli:
Natijalarni turli formatlarda saqlash va boshqa dasturlarga
eksport qilish
5.2 Hisoblash Optimizatsiyasi
Katta hajmdagi ma'lumotlar bilan ishlashda quyidagi optimizatsiya
texnikalari qo'llaniladi:
Parallel hisoblash:
OpenMP yoki CUDA yordamida ko'p yadroli va GPU
hisoblashlardan foydalanish
Xotira samaradorligi:
Sparse matritsa formatlaridan foydalanish va
ma'lumotlarni samarali saqlash
Adaptiv refinement:
Xatolik baholash asosida panjarani avtomatik
zichlashtirish
5.3 Kod Misolı va Realizatsiya
python
class
CubicSpline
:
def
__init__
(self, x, y):
self.x
=
np.array(x)
self.y
=
np.array(y)
self.n
=
len
(x)
self.coefficients
=
self._calculate_coefficients()
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
78
def
_calculate_coefficients
(self):
# Thomas algoritmi yordamida koeffitsientlarni hisoblash
h
=
np.diff(self.x)
alpha
=
np.zeros(self.n)
for
i
in
range
(
1
, self.n
-
1
):
alpha[i]
=
(
3
/
h[i])
*
(self.y[i
+
1
]
-
self.y[i])
-
\
(
3
/
h[i
-
1
])
*
(self.y[i]
-
self.y[i
-
1
])
# Uch diagonalli tizimni yechish
# ... (batafsil realizatsiya)
return
coefficients
Da
sturiy ta’minotni python d
asturlash tilida ishlab chiqildia ketma
ketligi taqdil qilindi.
Asosiy Sinflar:
1.
KubikSplayn
- Bir o'lchovli kubik splayn interpolatsiyasi
2.
BikubikSplayn
- Ikki o'lchovli bikubik splayn interpolatsiyasi
3.
FunksionalBoglanishModeli
- Modellarni boshqarish va
taqqoslash
Dasturning Imkoniyatlari:
Kubik Splaynlar:
•
Turli chegara shartlari (natural, clamped, periodic)
•
Hosilalar va integrallarni hisoblash
•
Vizualizatsiya va tahlil
Bikubik Splaynlar:
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
79
•
2D interpolatsiya
•
Qisman hosilalarni hisoblash
•
3D sirt va kontur diagrammalari
Model Baholash:
•
MSE, RMSE, R² metrikalar
•
Modellarni taqqoslash
•
Xatolik tahlili
Vizualizatsiya:
•
Interaktiv grafiklar
•
3D sirtlar
•
Kontur diagrammalari
Dasturdan Foydalanish:
Dasturni ishga tushirish uchun Python muhitida ishga tushiring. U avtomatik
ravishda demo funksiyalarni bajaradi va natijalarni ko'rsatadi.
Mustaqil foydalanish uchun misol:
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from scipy.interpolate import CubicSpline, RectBivariateSpline, interp2d
from scipy.optimize import minimize
import pandas as pd
from sklearn.metrics import mean_squared_error, r2_score
import warnings
warnings.filterwarnings('ignore')
class KubikSplayn:
"""Kubik splayn interpolatsiya sinfi"""
def __init__(self, x, y, boundary_conditions='natural'):
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
80
"""Kubik splayn yaratish Parametrlar:
x : array - x koordinatalari
y : array - y qiymatlari
boundary_conditions : str - chegara shartlari ('natural', 'clamped',
'periodic') """
self.x = np.array(x)
self.y = np.array(y)
self.boundary_conditions = boundary_conditions
self.spline = None
self._create_spline()
def _create_spline(self):
"""Kubik splayn yaratish"""
if self.boundary_conditions == 'natural':
bc_type = 'natural'
elif self.boundary_conditions == 'clamped':
bc_type = 'clamped'
elif self.boundary_conditions == 'periodic':
bc_type = 'periodic'
else:
bc_type = 'natural'
self.spline = CubicSpline(self.x, self.y, bc_type=bc_type)
def evaluate(self, x_new):
"""Yangi nuqtalarda qiymatlarni hisoblash"""
return self.spline(x_new)
def derivative(self, x_new, n=1):
"""Hosilalarni hisoblash"""
return self.spline.derivative(n)(x_new)
def integral(self, a, b):
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
81
"""Integrallarni hisoblash"""
return self.spline.integrate(a, b)
def plot(self, x_range=None, points=1000):
"""Splaynni vizualizatsiya qilish"""
if x_range is None:
x_range = (self.x.min(), self.x.max())
x_plot = np.linspace(x_range[0], x_range[1], points)
y_plot = self.evaluate(x_plot)
plt.figure(figsize=(10, 6))
plt.plot(x_plot, y_plot, 'b-', label='Kubik Splayn', linewidth=2)
plt.scatter(self.x, self.y, color='red', s=50, zorder=5, label='Ma\'lumot
nuqtalari')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Kubik Splayn Interpolatsiyasi')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()
class BikubikSplayn:
"""Bikubik splayn interpolatsiya sinfi"""
def __init__(self, x, y, z)
"""Bikubik splayn yaratish Parametrlar:
x : array - x koordinatalari
y : array - y koordinatalari
z : 2D array - z qiymatlari (x va y bo'yicha)"""
self.x = np.array(x)
self.y = np.array(y)
self.z = np.array(z)
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
82
self.spline = None
self._create_spline()
def _create_spline(self):
"""Bikubik splayn yaratish"""
# RectBivariateSpline ishlatish
self.spline = RectBivariateSpline(self.x, self.y, self.z, kx=3, ky=3)
def evaluate(self, x_new, y_new):
"""Yangi nuqtalarda qiymatlarni hisoblash"""
return self.spline(x_new, y_new, grid=False)
def evaluate_grid(self, x_new, y_new):
"""Grid formatida qiymatlarni hisoblash"""
return self.spline(x_new, y_new, grid=True)
def partial_derivative(self, x_new, y_new, dx=0, dy=0):
"""Qisman hosilalarni hisoblash"""
return self.spline(x_new, y_new, dx=dx, dy=dy, grid=False)
def plot_surface(self, points=50):
"""3D sirtni vizualizatsiya qilish"""
x_plot = np.linspace(self.x.min(), self.x.max(), points)
y_plot = np.linspace(self.y.min(), self.y.max(), points)
X_plot, Y_plot = np.meshgrid(x_plot, y_plot)
Z_plot = self.evaluate_grid(x_plot, y_plot)
fig = plt.figure(figsize=(12, 8))
ax = fig.add_subplot(111, projection='3d')
# Sirtni chizish
surf = ax.plot_surface(X_plot, Y_plot, Z_plot, cmap='viridis',
alpha=0.8)
# Original nuqtalarni qo'shish
X_orig, Y_orig = np.meshgrid(self.x, self.y)
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
83
ax.scatter(X_orig.ravel(), Y_orig.ravel(), self.z.ravel(),
color='red', s=50, alpha=1.0, label='Ma\'lumot nuqtalari')
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')
ax.set_title('Bikubik Splayn Interpolatsiyasi')
# Colorbar qo'shish
fig.colorbar(surf, shrink=0.5, aspect=5)
plt.show()
def plot_contour(self, points=50):
"""Kontur diagrammasini chizish"""
x_plot = np.linspace(self.x.min(), self.x.max(), points)
y_plot = np.linspace(self.y.min(), self.y.max(), points)
X_plot, Y_plot = np.meshgrid(x_plot, y_plot)
Z_plot = self.evaluate_grid(x_plot, y_plot)
plt.figure(figsize=(10, 8))
contour = plt.contourf(X_plot, Y_plot, Z_plot, levels=20,
cmap='viridis')
plt.colorbar(contour)
# Original nuqtalarni qo'shish
X_orig, Y_orig = np.meshgrid(self.x, self.y)
plt.scatter(X_orig.ravel(), Y_orig.ravel(),
color='red', s=30, alpha=0.8, label='Ma\'lumot nuqtalari')
plt.xlabel('X')
plt.ylabel('Y')
plt.title('Bikubik Splayn - Kontur Diagrammasi')
plt.legend()
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
84
plt.show()
class FunksionalBoglanishModeli:
"""Funksional bog'lanishlarni modellashtirish sinfi"""
def __init__(self):
self.models = {}
self.metrics = {}
def fit_cubic_spline(self, x, y, name='model', **kwargs):
"""Kubik splayn modelini o'rgatish"""
model = KubikSplayn(x, y, **kwargs)
self.models[name] = {'type': 'cubic', 'model': model, 'x': x, 'y': y}
return model
def fit_bicubic_spline(self, x, y, z, name='model', **kwargs):
"""Bikubik splayn modelini o'rgatish"""
model = BikubikSplayn(x, y, z, **kwargs)
self.models[name] = {'type': 'bicubic', 'model': model, 'x': x, 'y': y, 'z': z}
return model
def evaluate_model(self, name, *args):
"""Modelni baholash"""
if name not in self.models:
raise ValueError(f"Model '{name}' topilmadi")
model_info = self.models[name]
return model_info['model'].evaluate(*args)
def calculate_metrics(self, name, x_test=None, y_test=None,
z_test=None):
"""Model sifatini baholash metrikalarini hisoblash"""
if name not in self.models:
raise ValueError(f"Model '{name}' topilmadi")
model_info = self.models[name]
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
85
if model_info['type'] == 'cubic':
if x_test is None:
x_test = model_info['x']
y_true = model_info['y']
else:
y_true = y_test
y_pred = model_info['model'].evaluate(x_test)
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_true, y_pred)
self.metrics[name] = {
'MSE': mse,
'RMSE': rmse,
'R²': r2
}
elif model_info['type'] == 'bicubic':
if x_test is None:
X_orig, Y_orig = np.meshgrid(model_info['x'], model_info['y'])
x_test = X_orig.ravel()
y_test = Y_orig.ravel()
z_true = model_info['z'].ravel()
else:
z_true = z_test
z_pred = model_info['model'].evaluate(x_test, y_test)
mse = mean_squared_error(z_true, z_pred)
rmse = np.sqrt(mse)
r2 = r2_score(z_true, z_pred)
self.metrics[name] = {
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
86
'MSE': mse,
'RMSE': rmse,
'R²': r2
}
return self.metrics[name]
def compare_models(self):
"""Modellarni taqqoslash"""
if not self.metrics:
print("Avval modellar uchun metrikalarni hisoblang!")
return
df = pd.DataFrame(self.metrics).T
print("Model Taqqoslashi:")
print("="*50)
print(df.round(6))
return df
def plot_comparison(self, model_names=None):
"""Modellarni vizual taqqoslash"""
if model_names is None:
model_names = list(self.models.keys())
for name in model_names:
model_info = self.models[name]
if model_info['type'] == 'cubic':
model_info['model'].plot()
plt.title(f'Model: {name}')
elif model_info['type'] == 'bicubic':
model_info['model'].plot_surface()
def generate_test_data_1d(func_type='sin', n_points=20, noise_level=0.1):
"""1D test ma'lumotlarini yaratish"""
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
87
x = np.linspace(0, 4*np.pi, n_points)
if func_type == 'sin':
y_true = np.sin(x) + 0.5*np.cos(2*x)
elif func_type == 'poly':
y_true = 0.1*x**3 - 0.5*x**2 + x + 2
elif func_type == 'exp':
y_true = np.exp(-0.5*x) * np.cos(2*x)
else:
y_true = np.sin(x)
# Shovqin qo'shish
noise = np.random.normal(0, noise_level, len(x))
y = y_true + noise
return x, y, y_true
def generate_test_data_2d(func_type='sin_cos', nx=10, ny=10,
noise_level=0.1):
"""2D test ma'lumotlarini yaratish"""
x = np.linspace(0, 2*np.pi, nx)
y = np.linspace(0, 2*np.pi, ny)
X, Y = np.meshgrid(x, y)
if func_type == 'sin_cos':
Z_true = np.sin(X) * np.cos(Y)
elif func_type == 'gaussian':
Z_true = np.exp(-(X-np.pi)**2/2 - (Y-np.pi)**2/2)
elif func_type == 'saddle':
Z_true = X**2 - Y**2
else:
Z_true = np.sin(X) * np.cos(Y)
# Shovqin qo'shish
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
88
noise = np.random.normal(0, noise_level, Z_true.shape)
Z = Z_true + noise
return x, y, Z, Z_true
def demo_kubik_splayn():
"""Kubik splayn demo"""
print("KUBIK SPLAYN DEMO")
print("="*50)
# Test ma'lumotlarini yaratish
x, y, y_true = generate_test_data_1d('sin', n_points=15, noise_level=0.2)
# Model yaratish
model = FunksionalBoglanishModeli()
# Har xil chegara shartlari bilan splaynlar yaratish
spline_natural = model.fit_cubic_spline(x, y, 'natural',
boundary_conditions='natural')
spline_clamped = model.fit_cubic_spline(x, y, 'clamped',
boundary_conditions='clamped')
# Metrikalarni hisoblash
model.calculate_metrics('natural')
model.calculate_metrics('clamped')
# Natijalarni ko'rsatish
model.compare_models()
# Vizualizatsiya
x_fine = np.linspace(x.min(), x.max(), 200)
y_natural = spline_natural.evaluate(x_fine)
y_clamped = model.evaluate_model('clamped', x_fine)
plt.figure(figsize=(12, 8))
plt.plot(x_fine, y_natural, 'b-', label='Natural Splayn', linewidth=2)
plt.plot(x_fine, y_clamped, 'g-', label='Clamped Splayn', linewidth=2)
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
89
plt.scatter(x, y, color='red', s=50, zorder=5, label='Ma\'lumot nuqtalari')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Kubik Splayn Turlari Taqqoslash')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()
def demo_bikubik_splayn():
"""Bikubik splayn demo"""
print("\nBIKUBIK SPLAYN DEMO")
print("="*50)
# Test ma'lumotlarini yaratish
x, y, z, z_true = generate_test_data_2d('sin_cos', nx=8, ny=8,
noise_level=0.1)
# Model yaratish
model = FunksionalBoglanishModeli()
bikubik = model.fit_bicubic_spline(x, y, z, 'bikubik')
# Metrikalarni hisoblash
model.calculate_metrics('bikubik')
model.compare_models()
# Vizualizatsiya
bikubik.plot_surface()
bikubik.plot_contour()
def advanced_analysis():
"""Ilg'or tahlil - model taqqoslash va optimizatsiya"""
print("\nILG'OR TAHLIL")
print("="*50)
# Murakkab 1D funksiya
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
90
x = np.linspace(0, 10, 25)
y_true = np.sin(x) * np.exp(-0.2*x) + 0.5*np.cos(3*x)
noise = np.random.normal(0, 0.1, len(x))
y = y_true + noise
# Turli xil splaynlarni yaratish
model = FunksionalBoglanishModeli()
# Har xil parametrlar bilan
model.fit_cubic_spline(x, y, 'natural', boundary_conditions='natural')
model.fit_cubic_spline(x, y, 'clamped', boundary_conditions='clamped')
# Test ma'lumotlari uchun
x_test = np.linspace(0, 10, 100)
y_test_true = np.sin(x_test) * np.exp(-0.2*x_test) + 0.5*np.cos(3*x_test)
# Metrikalarni hisoblash
for name in ['natural', 'clamped']:
y_pred = model.evaluate_model(name, x_test)
mse = mean_squared_error(y_test_true, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_test_true, y_pred)
model.metrics[name] = {'MSE': mse, 'RMSE': rmse, 'R²': r2}
# Natijalar
comparison = model.compare_models()
# Eng yaxshi modelni tanlash
best_model = comparison['R²'].idxmax()
print(f"\nEng yaxshi model: {best_model}")
print(f"R² = {comparison.loc[best_model, 'R²']:.6f}")
# Vizualizatsiya
plt.figure(figsize=(14, 6))
plt.subplot(1, 2, 1)
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
91
for name in ['natural', 'clamped']:
y_pred = model.evaluate_model(name, x_test)
plt.plot(x_test, y_pred, label=f'{name}
(R²={model.metrics[name]["R²"]:.4f})', linewidth=2)
plt.plot(x_test, y_test_true, 'k--', label='Haqiqiy funksiya', alpha=0.7)
plt.scatter(x, y, color='red', s=30, alpha=0.7, label='Ma\'lumot nuqtalari')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Model Taqqoslash')
plt.legend()
plt.grid(True, alpha=0.3)
plt.subplot(1, 2, 2)
# Xatolik tahlili
for name in ['natural', 'clamped']:
y_pred = model.evaluate_model(name, x_test)
error = y_test_true - y_pred
plt.plot(x_test, error, label=f'{name} xatoligi', linewidth=2)
plt.axhline(y=0, color='k', linestyle='--', alpha=0.5)
plt.xlabel('x')
plt.ylabel('Xatolik')
plt.title('Xatolik Tahlili')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()
if __name__ == "__main__":
# Demo dasturlarini ishga tushirish
demo_kubik_splayn()
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
92
demo_bikubik_splayn()
advanced_analysis()
print("\n" + "="*60)
print("DASTUR YAKUNLANDI")
print("="*60)
print("Bu dastur quyidagi imkoniyatlarni taqdim etadi:")
print("• Kubik splayn interpolatsiyasi")
print("• Bikubik splayn interpolatsiyasi")
print("• Model sifatini baholash (MSE, RMSE, R²)")
print("• Vizualizatsiya va taqqoslash")
print("• Ilg'or tahlil va optimizatsiya")
6. Eksperimental Natijalar va Tahlil
Ishlab chiqilgan usullarning samaradorligini baholash uchun quyidagi test
ssenariylari ishlatilgan:
Sintetik harorat maydonlari:
Ma'lum analitik funksiyalar asosida
yaratilgan test ma'lumotlari
Eksperimental ma'lumotlar:
Haqiqiy termal o'lchashlar natijasida olingan
harorat taqsimoti
Shovqinli ma'lumotlar:
O'lchash xatoliklari ta'sirini baholash uchun
shovqin qo'shilgan ma'lumotlar
Samaradorlik Ko'rsatkichlari.
Bikubik splaynlarning yuqori aniqligini quyidagi ko'rsatkichlar tasdiqlaydi:
Interpolyatsiya xatoligi:
O'rtacha kvadrat xatolik (RMSE) < 0.1°C
Hisoblash vaqti:
1000×1000 panjara uchun < 2 soniya
Xotira sarfi:
Linear scaling O(n²) harorat nuqtalari soni bilan
Boshqa Usullar bilan Taqqoslash
Usul
RMSE (°C)
Vaqt (s)
Xotira (MB)
Bikubik Splayn
0.08
1.7
45
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
93
Usul
RMSE (°C)
Vaqt (s)
Xotira (MB)
Bilinear
0.25
0.3
20
Kriging
0.12
8.4
120
RBF
0.15
3. 8
85
Xulosa
Ushbu tadqiqot kubik va bikubik splaynlarning funksional bog'lanishlarni
modellashtirish, ayniqsa harorat maydonlarini tahlil qilish sohasidagi kuchli
imkoniyatlarini namoyish etdi. Ishlab chiqilgan matematik ramka va dasturiy
yechimlar yuqori aniqlik, hisoblash samaradorligi va foydalanish qulayligini
ta'minlaydi.
Asosiy yutuqlar:
•
Splayn asosidagi modellashtirish uchun to'liq nazariy va amaliy
ramka yaratildi
•
Harorat maydonlarini yuqori aniqlik bilan interpolyatsiya qilish
algoritmlari ishlab chiqildi
•
Zamonaviy dasturiy ta'minot vositalari yordamida samarali
realizatsiya amalga oshirildi
•
Eksperimental natijalar usulning samaradorligini tasdiqladi
Kelajak tadqiqot yo'nalishlari:
Adaptiv splaynlar:
Mahalliy xatolik baholash asosida avtomatik panjara
zichligini boshqarish
3D kengaytmalar:
Trikubik splaynlar yordamida uch o'lchovli harorat
maydonlarini modellashtirish
Vaqt o'zgaruvchan maydonlar:
Vaqtga bog'liq harorat taqsimotini
modellashtirish uchun 4D splaynlar
Mashinali o'rganish integratsiyasi:
Neural network bilan splayn usullarini
birlashtirishning gibrid yondashuvlari
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
94
Real vaqt qo'llanilishi:
IoT sensorlar ma'lumotlari asosida real vaqt
rejimida harorat maydonlarini kuzatish va bashorat qilish tizimlari
Bu tadqiqot splayn asosidagi modellashtirish usullarining keng
imkoniyatlarini ochib berdi va kelajakda yanada murakkab va samarali yechimlar
yaratish uchun mustahkam asos yaratdi.
FOYDALANILGAN ADABIYOTLAR
1.
De Boor, C. (2001).
A Practical Guide to Splines
. Springer-
Verlag.
2.
Schumaker, L. L. (2007).
Spline Functions: Basic Theory
.
Cambridge University Press.
3.
Prautzsch, H., Boehm, W., & Paluszny, M. (2002).
Bézier and
B-Spline Techniques
. Springer.
4.
Burden, R. L., & Faires, J. D. (2010).
Numerical Analysis
.
Brooks Cole.
5.
Press, W. H., et al. (2007).
Numerical Recipes: The Art of
Scientific Computing
. Cambridge University Press.
6.
de Boor, C.
(1978).
A Practical Guide to Splines
. Springer-
Verlag.
7.
Splaynlar asoslari va kubik splaynlar nazariyasining asosiy
manbasi.
8.
Press, W.H., Teukolsky, S.A., Vetterling, W.T., Flannery,
B.P.
(2007).
Numerical Recipes: The Art of Scientific Computing
(3rd ed.).
Cambridge University Press.
9.
Splaynlar bilan interpolatsiya va hisoblash usullari.
10.
Burden, R.L., & Faires, J.D.
(2011).
Numerical Analysis
(9th
ed.). Brooks/Cole.
11.
Interpolatsiya, kubik splaynlar va ularning tahlili.
https://scientific-jl.com/luch/
Часть
-47
_ Том
-2_
июнь
-2025
95
12.
Epperson, J.F.
(2013).
An Introduction to Numerical Methods
and Analysis
. Wiley.
13.
Bikubik splaynlar va ikki o‘lchamli interpolatsiya asoslari.
14.
Kress, R.
(1998).
Numerical Analysis
. Springer.
15.
Funksional bog‘lanishlar va ularni modellashtirish usullari.
16.
Oliphant, T.E.
(2006).
Guide to NumPy
. Trelgol Publishing.
17.
NumPy kutubxonasi yordamida vektorlar va matritsiyalarda
hisob-kitoblar.
18.
Virtanen, P. et al.
(2020).
SciPy 1.0: Fundamental Algorithms
for Scientific Computing in Python
.
Nature Methods
, 17, 261
–
272.
19.
SciPy kutubxonasidagi scipy.interpolate moduli yordamida
splaynlar bilan ishlash.
20.
McKinney, W.
(2018).
Python for Data Analysis
(2nd ed.).
O’Reilly Media.
21.
Pandas, NumPy orqali ma’lumotlar bilan ishlash.
22.
Hunter, J.D.
(2007).
Matplotlib: A 2D Graphics Environment
.
Computing in Science & Engineering
, 9(3), 90-95.
23.
Splaynlar grafigini chizish va vizualizatsiya qilish.
24.
Ramachandran, P., & Varoquaux, G.
(2011).
Mayavi: 3D
Visualization of Scientific Data
.
Computing in Science & Engineering
,
13(2), 40
–
51.
25.
Bikubik splaynlar asosidagi 3D graflarni yaratish.
26.
Jones, E., Oliphant, T., Peterson, P., et al.
(2001
–
).
SciPy:
Open source scientific tools for Python
27.
The Python Software Foundation.
Python Language
Reference, Version 3.
