History

leestott 343c66d101 🌐 Update translations via Co-op Translator		1 year ago
..
solution	🌐 Update translations via Co-op Translator	1 year ago
working	🌐 Update translations via Co-op Translator	1 year ago
README.md	🌐 Update translations via Co-op Translator	1 year ago
assignment.md	🌐 Update translations via Co-op Translator	1 year ago

README.md

ARIMA सँग समय श्रृंखला पूर्वानुमान

अघिल्लो पाठमा, तपाईंले समय श्रृंखला पूर्वानुमानको बारेमा केही सिक्नुभयो र विद्युत लोडको उतार-चढ़ावलाई देखाउने डेटासेट लोड गर्नुभयो।

🎥 माथिको छविमा क्लिक गर्नुहोस्: ARIMA मोडेलहरूको संक्षिप्त परिचय। यो उदाहरण R मा गरिएको छ, तर अवधारणाहरू सबै ठाउँमा लागू हुन्छन्।

पाठपूर्व क्विज

परिचय

यस पाठमा, तपाईं ARIMA: AutoRegressive Integrated Moving Average प्रयोग गरेर मोडेल निर्माण गर्ने विशेष तरिका पत्ता लगाउनुहुनेछ। ARIMA मोडेलहरू विशेष गरी गैर-स्टेशनरी डाटालाई फिट गर्न उपयुक्त हुन्छन्।

सामान्य अवधारणाहरू

ARIMA सँग काम गर्न सक्षम हुन, तपाईंले केही अवधारणाहरू जान्न आवश्यक छ:

🎓 स्टेशनरीटी। सांख्यिकीय सन्दर्भमा, स्टेशनरीटी भनेको समयसँगै सार्दा पनि वितरण नबदलिने डाटालाई जनाउँछ। गैर-स्टेशनरी डाटाले, त्यसपछि, विश्लेषण गर्न परिवर्तन गर्नुपर्ने ट्रेन्डका कारण उतार-चढ़ाव देखाउँछ। उदाहरणका लागि, मौसमीपनले डाटामा उतार-चढ़ाव ल्याउन सक्छ, जसलाई 'मौसमी-डिफरेन्सिङ' प्रक्रियाबाट हटाउन सकिन्छ।
🎓 डिफरेन्सिङ। सांख्यिकीय सन्दर्भमा, डिफरेन्सिङ भनेको गैर-स्टेशनरी डाटालाई स्थिर बनाउन परिवर्तन गर्ने प्रक्रिया हो, जसले यसको गैर-निरन्तर ट्रेन्डलाई हटाउँछ। "डिफरेन्सिङले समय श्रृंखलाको स्तरमा हुने परिवर्तनलाई हटाउँछ, ट्रेन्ड र मौसमीपनलाई समाप्त गर्छ र यसरी श्रृंखलाको औसतलाई स्थिर बनाउँछ।" Shixiong et al को पेपर

समय श्रृंखलाको सन्दर्भमा ARIMA

समय श्रृंखला मोडेल गर्न र यसमा आधारित भविष्यवाणी गर्न ARIMA कसरी मद्दत गर्छ भन्ने बुझ्न यसको भागहरूलाई खोलौं।

AR - अटोरेग्रेसिभको लागि। अटोरेग्रेसिभ मोडेलहरूले, नामले नै जनाएझैं, तपाईंको डाटाको अघिल्लो मानहरू (जसलाई 'लाग्स' भनिन्छ) विश्लेषण गर्न 'पछाडि' हेर्छन् र तिनीहरूबारे धारणाहरू बनाउँछन्। उदाहरणका लागि, मासिक पेन्सिल बिक्री देखाउने डाटा। प्रत्येक महिनाको बिक्री कुललाई डाटासेटमा 'विकसित हुने भेरिएबल' मानिन्छ। यो मोडेल यसरी निर्माण गरिन्छ कि "रुचिको विकसित हुने भेरिएबललाई यसको आफ्नै पछिल्लो (अर्थात्, अघिल्लो) मानहरूमा रिग्रेस गरिन्छ।" विकिपीडिया
I - इन्टिग्रेटेडको लागि। समान 'ARMA' मोडेलहरूको विपरीत, ARIMA मा 'I' ले यसको इन्टिग्रेटेड पक्षलाई जनाउँछ। गैर-स्टेशनरीपन हटाउन डिफरेन्सिङ चरणहरू लागू गर्दा डाटा 'इन्टिग्रेटेड' हुन्छ।
MA - मुभिङ एभरेजको लागि। यस मोडेलको मुभिङ-एभरेज पक्षले आउटपुट भेरिएबललाई जनाउँछ, जुन हालको र अघिल्लो लाग्सको मानहरू अवलोकन गरेर निर्धारण गरिन्छ।

मुख्य कुरा: ARIMA समय श्रृंखला डाटाको विशेष स्वरूपलाई सकेसम्म नजिकबाट फिट गर्न प्रयोग गरिन्छ।

अभ्यास - ARIMA मोडेल निर्माण गर्नुहोस्

यस पाठको /working फोल्डर खोल्नुहोस् र notebook.ipynb फाइल फेला पार्नुहोस्।

statsmodels Python लाइब्रेरी लोड गर्न नोटबुक चलाउनुहोस्; तपाईंलाई ARIMA मोडेलहरूको लागि यो आवश्यक हुनेछ।
आवश्यक लाइब्रेरीहरू लोड गर्नुहोस्।

अब, डाटा प्लट गर्न उपयोगी थप केही लाइब्रेरीहरू लोड गर्नुहोस्:

import os
import warnings
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import datetime as dt
import math

from pandas.plotting import autocorrelation_plot
from statsmodels.tsa.statespace.sarimax import SARIMAX
from sklearn.preprocessing import MinMaxScaler
from common.utils import load_data, mape
from IPython.display import Image

%matplotlib inline
pd.options.display.float_format = '{:,.2f}'.format
np.set_printoptions(precision=2)
warnings.filterwarnings("ignore") # specify to ignore warning messages

/data/energy.csv फाइलबाट डाटा Pandas डाटाफ्रेममा लोड गर्नुहोस् र हेर्नुहोस्:
```
energy = load_data('./data')[['load']]
energy.head(10)
```
जनवरी 2012 देखि डिसेम्बर 2014 सम्मको सबै उपलब्ध ऊर्जा डाटा प्लट गर्नुहोस्। कुनै आश्चर्य हुनु हुँदैन किनभने हामीले यो डाटा अघिल्लो पाठमा देख्यौं:
```
energy.plot(y='load', subplots=True, figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()
```
अब, मोडेल निर्माण गरौं!

प्रशिक्षण र परीक्षण डाटासेटहरू सिर्जना गर्नुहोस्

अब तपाईंको डाटा लोड भयो, त्यसलाई प्रशिक्षण र परीक्षण सेटहरूमा विभाजन गर्न सक्नुहुन्छ। तपाईं आफ्नो मोडेललाई प्रशिक्षण सेटमा प्रशिक्षण दिनुहुनेछ। सामान्य रूपमा, मोडेलले प्रशिक्षण पूरा गरेपछि, तपाईं यसको सटीकता परीक्षण सेट प्रयोग गरेर मूल्याङ्कन गर्नुहुनेछ। तपाईंले सुनिश्चित गर्नुपर्छ कि परीक्षण सेटले प्रशिक्षण सेटको तुलनामा समयको पछिल्लो अवधि समेट्छ ताकि मोडेलले भविष्यको समय अवधिबाट जानकारी प्राप्त नगरोस्।

सेप्टेम्बर 1 देखि अक्टोबर 31, 2014 सम्मको दुई महिनाको अवधि प्रशिक्षण सेटमा छुट्याउनुहोस्। परीक्षण सेटले नोभेम्बर 1 देखि डिसेम्बर 31, 2014 सम्मको दुई महिनाको अवधि समेट्नेछ:
```
train_start_dt = '2014-11-01 00:00:00'
test_start_dt = '2014-12-30 00:00:00'
```
यो डाटाले दैनिक ऊर्जा खपतलाई प्रतिबिम्बित गर्ने भएकाले, त्यहाँ बलियो मौसमी ढाँचा छ, तर खपत हालका दिनहरूको खपतसँग सबैभन्दा मिल्दोजुल्दो छ।
भिन्नताहरूलाई दृश्यात्मक बनाउनुहोस्:
```
energy[(energy.index < test_start_dt) & (energy.index >= train_start_dt)][['load']].rename(columns={'load':'train'}) \
    .join(energy[test_start_dt:][['load']].rename(columns={'load':'test'}), how='outer') \
    .plot(y=['train', 'test'], figsize=(15, 8), fontsize=12)
plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()
```
त्यसैले, डाटा प्रशिक्षणको लागि तुलनात्मक रूपमा सानो समयको झ्याल प्रयोग गर्नु पर्याप्त हुनुपर्छ।

नोट: ARIMA मोडेल फिट गर्न प्रयोग गरिने फङ्सनले फिटिङको क्रममा इन-स्याम्पल मान्यकरण प्रयोग गर्ने भएकाले, हामी मान्यकरण डाटालाई छोड्नेछौं।

प्रशिक्षणको लागि डाटा तयार गर्नुहोस्

अब, तपाईंले आफ्नो डाटालाई फिल्टर र स्केल गरेर प्रशिक्षणको लागि तयार गर्न आवश्यक छ। तपाईंले आफ्नो डाटासेटलाई आवश्यक समय अवधिहरू र स्तम्भहरू मात्र समावेश गर्न फिल्टर गर्नुहोस्, र डाटालाई 0,1 को अन्तरालमा प्रक्षेपण गर्न स्केल गर्नुहोस्।

मूल डाटासेटलाई माथि उल्लिखित समय अवधिहरू प्रति सेट र आवश्यक स्तम्भ 'load' र मिति मात्र समावेश गर्न फिल्टर गर्नुहोस्:
```
train = energy.copy()[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']]
test = energy.copy()[energy.index >= test_start_dt][['load']]

print('Training data shape: ', train.shape)
print('Test data shape: ', test.shape)
```
तपाईं डाटाको आकार देख्न सक्नुहुन्छ:
```
Training data shape:  (1416, 1)
Test data shape:  (48, 1)
```
डाटालाई (0, 1) को दायरामा स्केल गर्नुहोस्।
```
scaler = MinMaxScaler()
train['load'] = scaler.fit_transform(train)
train.head(10)
```

मूल बनाम स्केल गरिएको डाटालाई दृश्यात्मक बनाउनुहोस्:

energy[(energy.index >= train_start_dt) & (energy.index < test_start_dt)][['load']].rename(columns={'load':'original load'}).plot.hist(bins=100, fontsize=12)
train.rename(columns={'load':'scaled load'}).plot.hist(bins=100, fontsize=12)
plt.show()

मूल डाटा

स्केल गरिएको डाटा

अब तपाईंले स्केल गरिएको डाटालाई क्यालिब्रेट गर्नुभयो, तपाईं परीक्षण डाटालाई स्केल गर्न सक्नुहुन्छ:
```
test['load'] = scaler.transform(test)
test.head()
```

ARIMA कार्यान्वयन गर्नुहोस्

अब ARIMA कार्यान्वयन गर्ने समय हो! तपाईंले पहिले इन्स्टल गरेको statsmodels लाइब्रेरी प्रयोग गर्नुहुनेछ।

अब तपाईंले केही चरणहरू पालना गर्न आवश्यक छ:

SARIMAX() कल गरेर र मोडेल प्यारामिटरहरू: p, d, र q प्यारामिटरहरू, र P, D, र Q प्यारामिटरहरू पास गरेर मोडेल परिभाषित गर्नुहोस्।
fit() फङ्सन कल गरेर प्रशिक्षण डाटाको लागि मोडेल तयार गर्नुहोस्।
forecast() फङ्सन कल गरेर र पूर्वानुमान गर्न चरणहरूको संख्या (होराइजन) निर्दिष्ट गरेर भविष्यवाणी गर्नुहोस्।

🎓 यी सबै प्यारामिटरहरू केका लागि हुन्? ARIMA मोडेलमा 3 प्यारामिटरहरू हुन्छन्, जसले समय श्रृंखलाको प्रमुख पक्षहरू: मौसमीपन, ट्रेन्ड, र आवाज मोडल गर्न मद्दत गर्छ। यी प्यारामिटरहरू हुन्:

p: मोडेलको अटोरेग्रेसिभ पक्षसँग सम्बन्धित प्यारामिटर, जसले अघिल्लो मानहरू समावेश गर्छ।
d: मोडेलको इन्टिग्रेटेड भागसँग सम्बन्धित प्यारामिटर, जसले समय श्रृंखलामा डिफरेन्सिङ (🎓 डिफरेन्सिङ सम्झनुहोस् 👆?) को मात्रा प्रभावित गर्छ।
q: मोडेलको मुभिङ-एभरेज भागसँग सम्बन्धित प्यारामिटर।

नोट: यदि तपाईंको डाटामा मौसमी पक्ष छ - जुन यसमा छ - , हामी मौसमी ARIMA मोडेल (SARIMA) प्रयोग गर्छौं। यस अवस्थामा तपाईंले अर्को सेटका प्यारामिटरहरू: P, D, र Q प्रयोग गर्न आवश्यक छ, जसले p, d, र q जस्तै सम्बन्धहरू वर्णन गर्छ, तर मोडेलका मौसमी कम्पोनेन्टहरूसँग सम्बन्धित हुन्छन्।

आफ्नो मनपर्ने होराइजन मान सेट गर्नुहोस्। 3 घण्टा प्रयास गरौं:
```
# Specify the number of steps to forecast ahead
HORIZON = 3
print('Forecasting horizon:', HORIZON, 'hours')
```
ARIMA मोडेलका प्यारामिटरहरूको लागि उत्तम मानहरू चयन गर्नु चुनौतीपूर्ण हुन सक्छ किनभने यो केही हदसम्म व्यक्तिपरक र समय खपत गर्ने हुन्छ। तपाईं pyramid लाइब्रेरी बाट auto_arima() फङ्सन प्रयोग गर्न विचार गर्न सक्नुहुन्छ।
अहिलेका लागि राम्रो मोडेल फेला पार्न केही म्यानुअल चयनहरू प्रयास गर्नुहोस्।
```
order = (4, 1, 0)
seasonal_order = (1, 1, 0, 24)

model = SARIMAX(endog=train, order=order, seasonal_order=seasonal_order)
results = model.fit()

print(results.summary())
```
परिणामहरूको तालिका प्रिन्ट हुन्छ।

तपाईंले आफ्नो पहिलो मोडेल निर्माण गर्नुभयो! अब हामीले यसलाई मूल्याङ्कन गर्ने तरिका फेला पार्न आवश्यक छ।

आफ्नो मोडेल मूल्याङ्कन गर्नुहोस्

तपाईंको मोडेल मूल्याङ्कन गर्न, तथाकथित walk forward मान्यकरण प्रदर्शन गर्न सक्नुहुन्छ। व्यवहारमा, समय श्रृंखला मोडेलहरू प्रत्येक पटक नयाँ डाटा उपलब्ध हुँदा पुनः प्रशिक्षण गरिन्छ। यसले मोडेललाई प्रत्येक समय चरणमा उत्तम पूर्वानुमान गर्न अनुमति दिन्छ।

यो प्रविधि प्रयोग गरेर समय श्रृंखलाको सुरुदेखि, प्रशिक्षण डाटासेटमा मोडेल प्रशिक्षण गर्नुहोस्। त्यसपछि अर्को समय चरणमा भविष्यवाणी गर्नुहोस्। भविष्यवाणीलाई ज्ञात मानसँग तुलना गरेर मूल्याङ्कन गरिन्छ। त्यसपछि प्रशिक्षण सेटलाई ज्ञात मान समावेश गर्न विस्तार गरिन्छ र प्रक्रिया दोहोरिन्छ।

नोट: तपाईंले प्रशिक्षण सेटको झ्याललाई स्थिर राख्नुपर्छ ताकि प्रत्येक पटक तपाईंले प्रशिक्षण सेटमा नयाँ अवलोकन थप्दा, सेटको सुरुदेखि अवलोकन हटाउनुहोस्।

यो प्रक्रिया मोडेलले व्यवहारमा कसरी प्रदर्शन गर्नेछ भन्ने अधिक बलियो अनुमान प्रदान गर्दछ। यद्यपि, यसले यति धेरै मोडेलहरू सिर्जना गर्ने कम्प्युटेसन लागतमा आउँछ। यदि डाटा सानो छ वा मोडेल सरल छ भने यो स्वीकार्य छ, तर स्केलमा समस्या हुन सक्छ।

Walk-forward मान्यकरण समय श्रृंखला मोडेल मूल्याङ्कनको सुनौलो मानक हो र तपाईंका आफ्ना परियोजनाहरूका लागि सिफारिस गरिन्छ।

प्रत्येक HORIZON चरणको लागि परीक्षण डाटा पोइन्ट सिर्जना गर्नुहोस्।

test_shifted = test.copy()

for t in range(1, HORIZON+1):
    test_shifted['load+'+str(t)] = test_shifted['load'].shift(-t, freq='H')

test_shifted = test_shifted.dropna(how='any')
test_shifted.head(5)

		load	load+1	load+2
2014-12-30	00:00:00	0.33	0.29	0.27
2014-12-30	01:00:00	0.29	0.27	0.27
2014-12-30	02:00:00	0.27	0.27	0.30
2014-12-30	03:00:00	0.27	0.30	0.41
2014-12-30	04:00:00	0.30	0.41	0.57

डाटालाई यसको होराइजन पोइन्ट अनुसार तेर्सो रूपमा सारिएको छ।

स्लाइडिङ विन्डो दृष्टिकोणमा परीक्षण डाटामा भविष्यवाणी गर्नुहोस्, परीक्षण डाटाको लम्बाइको आकारमा लूप प्रयोग गरेर:

%%time
training_window = 720 # dedicate 30 days (720 hours) for training

train_ts = train['load']
test_ts = test_shifted

history = [x for x in train_ts]
history = history[(-training_window):]

predictions = list()

order = (2, 1, 0)
seasonal_order = (1, 1, 0, 24)

for t in range(test_ts.shape[0]):
    model = SARIMAX(endog=history, order=order, seasonal_order=seasonal_order)
    model_fit = model.fit()
    yhat = model_fit.forecast(steps = HORIZON)
    predictions.append(yhat)
    obs = list(test_ts.iloc[t])
    # move the training window
    history.append(obs[0])
    history.pop(0)
    print(test_ts.index[t])
    print(t+1, ': predicted =', yhat, 'expected =', obs)

तपाईं प्रशिक्षण भइरहेको हेर्न सक्नुहुन्छ:

2014-12-30 00:00:00
1 : predicted = [0.32 0.29 0.28] expected = [0.32945389435989236, 0.2900626678603402, 0.2739480752014323]

2014-12-30 01:00:00
2 : predicted = [0.3  0.29 0.3 ] expected = [0.2900626678603402, 0.2739480752014323, 0.26812891674127126]

2014-12-30 02:00:00
3 : predicted = [0.27 0.28 0.32] expected = [0.2739480752014323, 0.26812891674127126, 0.3025962399283795]

भविष्यवाणीलाई वास्तविक लोडसँग तुलना गर्नुहोस्:

eval_df = pd.DataFrame(predictions, columns=['t+'+str(t) for t in range(1, HORIZON+1)])
eval_df['timestamp'] = test.index[0:len(test.index)-HORIZON+1]
eval_df = pd.melt(eval_df, id_vars='timestamp', value_name='prediction', var_name='h')
eval_df['actual'] = np.array(np.transpose(test_ts)).ravel()
eval_df[['prediction', 'actual']] = scaler.inverse_transform(eval_df[['prediction', 'actual']])
eval_df.head()

आउटपुट

		timestamp	h	prediction	actual
0	2014-12-30	00:00:00	t+1	3,008.74	3,023.00
1	2014-12-30	01:00:00	t+1	2,955.53	2,935.00
2	2014-12-30	02:00:00	t+1	2,900.17	2,899.00
3	2014-12-30	03:00:00	t+1	2,917.69	2,886.00
4	2014-12-30	04:00:00	t+1	2,946.99	2,963.00

घण्टाको डाटाको भविष्यवाणीलाई वास्तविक लोडसँग तुलना गर्नुहोस्। यो कति सटीक छ?

मोडेलको सटीकता जाँच गर्नुहोस्

तपाईंको मोडेलको सटीकता जाँच गर्न यसको mean absolute percentage error (MAPE) सबै भविष्यवाणीहरूमा परीक्षण गर्नुहोस्।

🧮 गणित देखाउनुहोस्

MAPE भविष्यवाणीको सटीकता देखाउन प्रयोग गरिन्छ, जुन माथिको सूत्रद्वारा परिभाषित अनुपात हो। वास्तविक र भविष्यवाणी गरिएको बीचको भिन्नता वास्तविकद्वारा भाग गरिन्छ।
"यस गणनामा रहेको पूर्ण मान प्रत्येक भविष्यवाणी गरिएको समय बिन्दुका लागि जोडिन्छ र फिट गरिएका बिन्दुहरूको संख्या n द्वारा भाग गरिन्छ।" wikipedia

कोडमा समीकरण व्यक्त गर्नुहोस्:

if(HORIZON > 1):
    eval_df['APE'] = (eval_df['prediction'] - eval_df['actual']).abs() / eval_df['actual']
    print(eval_df.groupby('h')['APE'].mean())

एक चरणको MAPE गणना गर्नुहोस्:
```
print('One step forecast MAPE: ', (mape(eval_df[eval_df['h'] == 't+1']['prediction'], eval_df[eval_df['h'] == 't+1']['actual']))*100, '%')
```
एक चरणको पूर्वानुमान MAPE: 0.5570581332313952 %
बहु-चरणको पूर्वानुमान MAPE प्रिन्ट गर्नुहोस्:
```
print('Multi-step forecast MAPE: ', mape(eval_df['prediction'], eval_df['actual'])*100, '%')
```
```
Multi-step forecast MAPE:  1.1460048657704118 %
```
राम्रो सानो संख्या उत्तम हुन्छ: विचार गर्नुहोस् कि 10 को MAPE भएको पूर्वानुमान 10% ले गलत छ।

तर सधैंझैं, यस्तो सटीकता मापनलाई दृश्यात्मक रूपमा हेर्न सजिलो हुन्छ, त्यसैले यसलाई प्लट गरौं:

 if(HORIZON == 1):
    ## Plotting single step forecast
    eval_df.plot(x='timestamp', y=['actual', 'prediction'], style=['r', 'b'], figsize=(15, 8))

else:
    ## Plotting multi step forecast
    plot_df = eval_df[(eval_df.h=='t+1')][['timestamp', 'actual']]
    for t in range(1, HORIZON+1):
        plot_df['t+'+str(t)] = eval_df[(eval_df.h=='t+'+str(t))]['prediction'].values

    fig = plt.figure(figsize=(15, 8))
    ax = plt.plot(plot_df['timestamp'], plot_df['actual'], color='red', linewidth=4.0)
    ax = fig.add_subplot(111)
    for t in range(1, HORIZON+1):
        x = plot_df['timestamp'][(t-1):]
        y = plot_df['t+'+str(t)][0:len(x)]
        ax.plot(x, y, color='blue', linewidth=4*math.pow(.9,t), alpha=math.pow(0.8,t))

    ax.legend(loc='best')

plt.xlabel('timestamp', fontsize=12)
plt.ylabel('load', fontsize=12)
plt.show()

🏆 एकदम राम्रो प्लट, जसले राम्रो सटीकता भएको मोडेल देखाउँछ। राम्रो काम!

🚀चुनौती

समय श्रृंखला मोडेलको सटीकता परीक्षण गर्ने तरिकाहरूमा गहिरो अध्ययन गर्नुहोस्। यस पाठमा हामी MAPE को बारेमा कुरा गर्छौं, तर के तपाईँ अन्य विधिहरू प्रयोग गर्न सक्नुहुन्छ? तिनीहरूको अनुसन्धान गर्नुहोस् र तिनीहरूलाई व्याख्या गर्नुहोस्। एउटा उपयोगी दस्तावेज यहाँ फेला पार्न सकिन्छ।

पाठपछिको प्रश्नोत्तरी

समीक्षा र आत्म-अध्ययन

यो पाठले ARIMA सँग समय श्रृंखला पूर्वानुमानको केवल आधारभूत पक्षहरूलाई समेट्छ। यस रिपोजिटरी र यसको विभिन्न मोडेल प्रकारहरूमा गहिरो अध्ययन गरेर समय श्रृंखला मोडेलहरू निर्माण गर्ने अन्य तरिकाहरू सिक्न समय निकाल्नुहोस्।

असाइनमेन्ट

नयाँ ARIMA मोडेल

अस्वीकरण:
यो दस्तावेज़ AI अनुवाद सेवा Co-op Translator प्रयोग गरेर अनुवाद गरिएको छ। हामी शुद्धताको लागि प्रयास गर्छौं, तर कृपया ध्यान दिनुहोस् कि स्वचालित अनुवादहरूमा त्रुटि वा अशुद्धता हुन सक्छ। यसको मूल भाषा मा रहेको मूल दस्तावेज़लाई आधिकारिक स्रोत मानिनुपर्छ। महत्वपूर्ण जानकारीको लागि, व्यावसायिक मानव अनुवाद सिफारिस गरिन्छ। यस अनुवादको प्रयोगबाट उत्पन्न हुने कुनै पनि गलतफहमी वा गलत व्याख्याको लागि हामी जिम्मेवार हुने छैनौं।