پیش‌بینی سری‌های زمانی با هوش مصنوعی: از مبانی تا پیاده‌سازی عملی

import pandas as pd
import matplotlib.pyplot as plt

# بارگذاری داده
df = pd.read_csv('sales_data.csv', parse_dates=['date'])
df.set_index('date', inplace=True)
# بررسی اولیه
print(df.info())
print(df.describe())
# رسم نمودار
df['sales'].plot(figsize=(15, 5))
plt.title('روند فروش در طول زمان')
plt.show()

# روش‌های مختلف پر کردن مقادیر گمشده
df.fillna(method='ffill')  # استفاده از آخرین مقدار معتبر
df.fillna(df.mean())  # استفاده از میانگین
df.interpolate(method='linear')  # درون‌یابی خطی

from scipy import stats

# شناسایی outliers با Z-score
z_scores = np.abs(stats.zscore(df['sales']))
outliers = df[z_scores > 3]

from sklearn.preprocessing import MinMaxScaler, StandardScaler

# مقیاس‌بندی به بازه 0-1
scaler = MinMaxScaler()
df['sales_scaled'] = scaler.fit_transform(df[['sales']])
# استانداردسازی (میانگین=0، انحراف معیار=1)
scaler = StandardScaler()
df['sales_standardized'] = scaler.fit_transform(df[['sales']])

from statsmodels.tsa.seasonal import seasonal_decompose

# جداسازی اجزای سری زمانی
decomposition = seasonal_decompose(df['sales'], model='additive', period=12)
trend = decomposition.trend
seasonal = decomposition.seasonal
residual = decomposition.resid
# رسم نمودار
decomposition.plot()
plt.show()

df['year'] = df.index.year
df['month'] = df.index.month
df['day'] = df.index.day
df['dayofweek'] = df.index.dayofweek
df['quarter'] = df.index.quarter
df['is_weekend'] = df.index.dayofweek.isin([5, 6]).astype(int)

# ایجاد ویژگی‌های تاخیری
for i in range(1, 8):
    df[f'sales_lag_{i}'] = df['sales'].shift(i)

# میانگین متحرک
df['sales_rolling_mean_7'] = df['sales'].rolling(window=7).mean()
df['sales_rolling_std_7'] = df['sales'].rolling(window=7).std()

# میانگین متحرک نمایی
df['sales_ewm'] = df['sales'].ewm(span=7, adjust=False).mean()

# تقسیم زمانی ساده
train_size = int(len(df) * 0.8)
train = df[:train_size]
test = df[train_size:]

# یا استفاده از Time Series Split
from sklearn.model_selection import TimeSeriesSplit
tscv = TimeSeriesSplit(n_splits=5)
for train_index, test_index in tscv.split(df):
    train = df.iloc[train_index]
    test = df.iloc[test_index]

from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout

# آماده‌سازی داده برای LSTM
def create_sequences(data, seq_length):
    X, y = [], []
    for i in range(len(data) - seq_length):
        X.append(data[i:i+seq_length])
        y.append(data[i+seq_length])
    return np.array(X), np.array(y)
seq_length = 30
X_train, y_train = create_sequences(train_scaled, seq_length)
X_test, y_test = create_sequences(test_scaled, seq_length)
# ساخت مدل LSTM
model = Sequential([
    LSTM(128, return_sequences=True, input_shape=(seq_length, 1)),
    Dropout(0.2),
    LSTM(64, return_sequences=False),
    Dropout(0.2),
    Dense(32, activation='relu'),
    Dense(1)
])
model.compile(optimizer='adam', loss='mse', metrics=['mae'])
# آموزش مدل
history = model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=32,
    validation_split=0.2,
    callbacks=[
        keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True),
        keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=5)
    ]
)

from prophet import Prophet

# آماده‌سازی داده برای Prophet
df_prophet = df.reset_index()
df_prophet.columns = ['ds', 'y']  # Prophet نیاز به این نام‌ها دارد
# ساخت و آموزش مدل
model = Prophet(
    seasonality_mode='multiplicative',
    yearly_seasonality=True,
    weekly_seasonality=True,
    daily_seasonality=False
)
# اضافه کردن تعطیلات
model.add_country_holidays(country_name='IR')
model.fit(df_prophet)
# پیش‌بینی
future = model.make_future_dataframe(periods=90)
forecast = model.predict(future)
# رسم نمودار
model.plot(forecast)
model.plot_components(forecast)

from sklearn.metrics import mean_absolute_error

mae = mean_absolute_error(y_test, predictions)
print(f'MAE: {mae}')

from sklearn.metrics import mean_squared_error

rmse = np.sqrt(mean_squared_error(y_test, predictions))
print(f'RMSE: {rmse}')

def mape(y_true, y_pred):
    return np.mean(np.abs((y_true - y_pred) / y_true)) * 100

mape_score = mape(y_test, predictions)
print(f'MAPE: {mape_score}%')

from sklearn.metrics import r2_score

r2 = r2_score(y_test, predictions)
print(f'R²: {r2}')

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from datetime import datetime

# بارگذاری داده
df = pd.read_csv('online_store_sales.csv')
df['date'] = pd.to_datetime(df['date'])
df = df.sort_values('date')
df.set_index('date', inplace=True)
# بررسی اولیه
print(f"تعداد رکوردها: {len(df)}")
print(f"بازه زمانی: {df.index.min()} تا {df.index.max()}")
print(f"\nآمار توصیفی:\n{df.describe()}")
# رسم نمودار
plt.figure(figsize=(15, 6))
plt.plot(df.index, df['sales'])
plt.title('روند فروش روزانه')
plt.xlabel('تاریخ')
plt.ylabel('فروش')
plt.grid(True)
plt.show()

from statsmodels.tsa.seasonal import seasonal_decompose

# تجزیه سری زمانی
decomposition = seasonal_decompose(df['sales'], model='multiplicative', period=7)
fig, axes = plt.subplots(4, 1, figsize=(15, 10))
decomposition.observed.plot(ax=axes[0], title='مشاهدات اصلی')
decomposition.trend.plot(ax=axes[1], title='روند')
decomposition.seasonal.plot(ax=axes[2], title='فصلی‌بودن')
decomposition.resid.plot(ax=axes[3], title='باقی‌مانده')
plt.tight_layout()
plt.show()

def create_features(df):
    df = df.copy()
    
    # ویژگی‌های زمانی
    df['dayofweek'] = df.index.dayofweek
    df['quarter'] = df.index.quarter
    df['month'] = df.index.month
    df['year'] = df.index.year
    df['dayofyear'] = df.index.dayofyear
    df['weekofyear'] = df.index.isocalendar().week
    df['is_weekend'] = (df.index.dayofweek >= 5).astype(int)
    
    # ویژگی‌های تاخیری
    for i in [1, 7, 14, 28]:
        df[f'sales_lag_{i}'] = df['sales'].shift(i)
    
    # ویژگی‌های پنجره‌ای
    for window in [7, 14, 28]:
        df[f'sales_rolling_mean_{window}'] = df['sales'].rolling(window=window).mean()
        df[f'sales_rolling_std_{window}'] = df['sales'].rolling(window=window).std()
        df[f'sales_rolling_min_{window}'] = df['sales'].rolling(window=window).min()
        df[f'sales_rolling_max_{window}'] = df['sales'].rolling(window=window).max()
    
    # میانگین متحرک نمایی
    df['sales_ewm_7'] = df['sales'].ewm(span=7, adjust=False).mean()
    df['sales_ewm_28'] = df['sales'].ewm(span=28, adjust=False).mean()
    
    return df

df_features = create_features(df)
df_features = df_features.dropna()

from sklearn.preprocessing import StandardScaler

# تقسیم داده
train_size = int(len(df_features) * 0.8)
train = df_features[:train_size]
test = df_features[train_size:]
# انتخاب ویژگی‌ها
feature_columns = [col for col in df_features.columns if col != 'sales']
target_column = 'sales'
X_train = train[feature_columns]
y_train = train[target_column]
X_test = test[feature_columns]
y_test = test[target_column]
# نرمال‌سازی
scaler_X = StandardScaler()
scaler_y = StandardScaler()
X_train_scaled = scaler_X.fit_transform(X_train)
X_test_scaled = scaler_X.transform(X_test)
y_train_scaled = scaler_y.fit_transform(y_train.values.reshape(-1, 1)).flatten()

from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.linear_model import Ridge
from xgboost import XGBRegressor
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, Dropout

# 1. Random Forest
rf_model = RandomForestRegressor(n_estimators=200, max_depth=15, random_state=42)
rf_model.fit(X_train, y_train)
rf_pred = rf_model.predict(X_test)
# 2. XGBoost
xgb_model = XGBRegressor(n_estimators=200, learning_rate=0.05, max_depth=7)
xgb_model.fit(X_train, y_train)
xgb_pred = xgb_model.predict(X_test)
# 3. Neural Network
nn_model = Sequential([
    Dense(128, activation='relu', input_shape=(X_train_scaled.shape[1],)),
    Dropout(0.3),
    Dense(64, activation='relu'),
    Dropout(0.2),
    Dense(32, activation='relu'),
    Dense(1)
])
nn_model.compile(optimizer='adam', loss='mse', metrics=['mae'])
nn_model.fit(
    X_train_scaled, y_train_scaled,
    epochs=100,
    batch_size=32,
    validation_split=0.2,
    verbose=0,
    callbacks=[tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)]
)
nn_pred_scaled = nn_model.predict(X_test_scaled).flatten()
nn_pred = scaler_y.inverse_transform(nn_pred_scaled.reshape(-1, 1)).flatten()

# میانگین وزن‌دار مدل‌ها
ensemble_pred = 0.3 * rf_pred + 0.4 * xgb_pred + 0.3 * nn_pred

# ارزیابی
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
def evaluate_model(y_true, y_pred, model_name):
    mae = mean_absolute_error(y_true, y_pred)
    rmse = np.sqrt(mean_squared_error(y_true, y_pred))
    r2 = r2_score(y_true, y_pred)
    mape = np.mean(np.abs((y_true - y_pred) / y_true)) * 100
    
    print(f"\n{model_name}:")
    print(f"MAE: {mae:.2f}")
    print(f"RMSE: {rmse:.2f}")
    print(f"R²: {r2:.4f}")
    print(f"MAPE: {mape:.2f}%")
evaluate_model(y_test, rf_pred, "Random Forest")
evaluate_model(y_test, xgb_pred, "XGBoost")
evaluate_model(y_test, nn_pred, "Neural Network")
evaluate_model(y_test, ensemble_pred, "Ensemble Model")

# اهمیت ویژگی‌ها در Random Forest
feature_importance = pd.DataFrame({
    'feature': feature_columns,
    'importance': rf_model.feature_importances_
}).sort_values('importance', ascending=False)

plt.figure(figsize=(10, 8))
sns.barplot(x='importance', y='feature', data=feature_importance.head(15))
plt.title('15 ویژگی مهم')
plt.show()

# رسم پیش‌بینی‌ها
plt.figure(figsize=(15, 6))
plt.plot(test.index, y_test, label='واقعی', linewidth=2)
plt.plot(test.index, ensemble_pred, label='پیش‌بینی', linewidth=2, alpha=0.7)
plt.title('مقایسه فروش واقعی و پیش‌بینی شده')
plt.xlabel('تاریخ')
plt.ylabel('فروش')
plt.legend()
plt.grid(True)
plt.show()

# رسم خطای پیش‌بینی
errors = y_test - ensemble_pred
plt.figure(figsize=(15, 4))
plt.plot(test.index, errors)
plt.axhline(y=0, color='r', linestyle='--')
plt.title('خطای پیش‌بینی')
plt.xlabel('تاریخ')
plt.ylabel('خطا')
plt.grid(True)
plt.show()