Tự động dự đoán doanh thu từ dữ liệu trong SQL Server bằng mô hình Python

Trong thế giới kinh doanh hiện đại, việc dự đoán doanh thu chính xác không chỉ là một lợi thế cạnh tranh mà còn là yếu tố sống còn đối với nhiều doanh nghiệp. Bài viết này sẽ hướng dẫn bạn cách xây dựng một hệ thống dự đoán doanh thu tự động bằng cách kết hợp SQL Server để lưu trữ và quản lý dữ liệu với sức mạnh của các mô hình học máy trong Python.

Tổng quan về quy trình dự đoán doanh thu

Quy trình dự đoán doanh thu tự động bao gồm các bước chính sau:

1. Thu thập và lưu trữ dữ liệu: Dữ liệu bán hàng, khách hàng, sản phẩm và các yếu tố ảnh hưởng được lưu trữ trong SQL Server
2. Tiền xử lý dữ liệu: Truy vấn, làm sạch, và chuẩn bị dữ liệu cho mô hình học máy
3. Xây dựng mô hình: Phát triển và huấn luyện các mô hình dự đoán doanh thu
4. Đánh giá và tối ưu hóa: Kiểm tra hiệu suất và điều chỉnh mô hình
5. Tự động hóa dự đoán: Tích hợp mô hình vào quy trình kinh doanh

Hãy đi sâu vào từng bước một.

Cài đặt công cụ và môi trường

Trước tiên, chúng ta cần cài đặt các thư viện Python cần thiết:

# Cài đặt thư viện cần thiết
pip install pyodbc sqlalchemy pandas numpy scikit-learn xgboost lightgbm tensorflow matplotlib seaborn joblib flask apscheduler

Danh sách các thư viện và mục đích sử dụng:

• pyodbc và sqlalchemy: Kết nối đến SQL Server
• pandas và numpy: Xử lý và phân tích dữ liệu
• scikit-learn, xgboost, lightgbm, tensorflow: Xây dựng mô hình học máy
• matplotlib và seaborn: Trực quan hóa dữ liệu
• joblib: Lưu và tải mô hình
• flask: Xây dựng API để phục vụ dự đoán
• apscheduler: Tự động hóa quy trình dự đoán định kỳ

Kết nối và truy vấn dữ liệu từ SQL Server

import pyodbc
import pandas as pd
from sqlalchemy import create_engine
import urllib

# Thông tin kết nối SQL Server
server = 'your_server_name'
database = 'your_database_name'
username = 'your_username'
password = 'your_password'
driver = '{ODBC Driver 17 for SQL Server}'  # Thay đổi tùy theo driver đã cài đặt

# Tạo kết nối PyODBC
conn_str = f'DRIVER={driver};SERVER={server};DATABASE={database};UID={username};PWD={password}'
conn = pyodbc.connect(conn_str)

# Tạo kết nối SQLAlchemy (hữu ích cho pandas to_sql)
quoted_conn_str = urllib.parse.quote_plus(conn_str)
engine = create_engine(f'mssql+pyodbc:///?odbc_connect={quoted_conn_str}')

# Truy vấn dữ liệu bán hàng lịch sử
historical_data_query = """
SELECT 
    o.OrderDate,
    c.CustomerID,
    c.Region,
    c.CustomerType,
    p.ProductID,
    p.Category,
    p.SubCategory,
    p.Price,
    p.Cost,
    DATEPART(WEEKDAY, o.OrderDate) AS OrderDay,
    DATEPART(MONTH, o.OrderDate) AS OrderMonth,
    DATEPART(QUARTER, o.OrderDate) AS OrderQuarter,
    DATEPART(YEAR, o.OrderDate) AS OrderYear,
    o.Discount,
    o.Quantity,
    (p.Price * o.Quantity * (1 - o.Discount)) AS Revenue,
    (p.Price * o.Quantity * (1 - o.Discount) - p.Cost * o.Quantity) AS Profit
FROM 
    Orders o
JOIN 
    Customers c ON o.CustomerID = c.CustomerID
JOIN 
    Products p ON o.ProductID = p.ProductID
WHERE 
    o.OrderDate BETWEEN '2020-01-01' AND '2022-12-31'
ORDER BY 
    o.OrderDate
"""

# Đọc kết quả vào DataFrame
sales_df = pd.read_sql(historical_data_query, conn)

# Kiểm tra dữ liệu
print(sales_df.head())
print(sales_df.info())
print(sales_df.describe())

Tiền xử lý dữ liệu cho mô hình dự đoán

import numpy as np
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split

# Thêm các tính năng thời gian
sales_df['OrderDate'] = pd.to_datetime(sales_df['OrderDate'])
sales_df['DayOfWeek'] = sales_df['OrderDate'].dt.dayofweek
sales_df['Month'] = sales_df['OrderDate'].dt.month
sales_df['Quarter'] = sales_df['OrderDate'].dt.quarter
sales_df['Year'] = sales_df['OrderDate'].dt.year
sales_df['IsWeekend'] = sales_df['DayOfWeek'].apply(lambda x: 1 if x >= 5 else 0)
sales_df['IsHoliday'] = 0  # Cần logic riêng để xác định ngày lễ

# Tổng hợp dữ liệu theo ngày
daily_sales = sales_df.groupby('OrderDate').agg({
    'Revenue': 'sum',
    'Quantity': 'sum',
    'Profit': 'sum'
}).reset_index()

# Thêm tính năng lag (doanh thu và số lượng của những ngày trước)
for lag in [1, 2, 3, 7, 14, 28]:
    daily_sales[f'Revenue_Lag_{lag}'] = daily_sales['Revenue'].shift(lag)
    daily_sales[f'Quantity_Lag_{lag}'] = daily_sales['Quantity'].shift(lag)

# Thêm tính năng rolling window (trung bình trong 7, 14, 30 ngày)
for window in [7, 14, 30]:
    daily_sales[f'Revenue_Rolling_{window}'] = daily_sales['Revenue'].rolling(window=window).mean()
    daily_sales[f'Quantity_Rolling_{window}'] = daily_sales['Quantity'].rolling(window=window).mean()

# Thêm tính năng khác như ngày trong tuần, tháng, quý, năm
daily_sales['DayOfWeek'] = daily_sales['OrderDate'].dt.dayofweek
daily_sales['Month'] = daily_sales['OrderDate'].dt.month
daily_sales['Quarter'] = daily_sales['OrderDate'].dt.quarter
daily_sales['Year'] = daily_sales['OrderDate'].dt.year
daily_sales['IsWeekend'] = daily_sales['DayOfWeek'].apply(lambda x: 1 if x >= 5 else 0)

# Loại bỏ các hàng có giá trị NaN (do các tính năng lag và rolling)
daily_sales = daily_sales.dropna().reset_index(drop=True)

# Chia dữ liệu thành biến độc lập (X) và biến phụ thuộc (y)
X = daily_sales.drop(['OrderDate', 'Revenue', 'Profit'], axis=1)
y = daily_sales['Revenue']

# Chia dữ liệu thành tập huấn luyện và tập kiểm tra
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Tiền xử lý dữ liệu với sklearn pipeline
numeric_features = [col for col in X.columns if X[col].dtype in ['int64', 'float64']]
categorical_features = [col for col in X.columns if X[col].dtype == 'object']

numeric_transformer = Pipeline(steps=[
    ('scaler', StandardScaler())
])

categorical_transformer = Pipeline(steps=[
    ('onehot', OneHotEncoder(handle_unknown='ignore'))
])

preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ])

# Áp dụng tiền xử lý
X_train_processed = preprocessor.fit_transform(X_train)
X_test_processed = preprocessor.transform(X_test)

print(f"Số lượng tính năng sau khi tiền xử lý: {X_train_processed.shape[1]}")

Xây dựng và huấn luyện mô hình

Chúng ta sẽ thử nghiệm với một số mô hình khác nhau để tìm ra mô hình tốt nhất:

from sklearn.linear_model import LinearRegression, Ridge, Lasso
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import xgboost as xgb
import lightgbm as lgb
import matplotlib.pyplot as plt
import seaborn as sns
import joblib
import time

# Hàm đánh giá mô hình
def evaluate_model(model, X_train, X_test, y_train, y_test, model_name):
    start_time = time.time()
    
    # Huấn luyện mô hình
    model.fit(X_train, y_train)
    
    # Dự đoán
    y_train_pred = model.predict(X_train)
    y_test_pred = model.predict(X_test)
    
    # Tính thời gian huấn luyện
    train_time = time.time() - start_time
    
    # Tính các độ đo hiệu suất
    train_mae = mean_absolute_error(y_train, y_train_pred)
    test_mae = mean_absolute_error(y_test, y_test_pred)
    train_rmse = np.sqrt(mean_squared_error(y_train, y_train_pred))
    test_rmse = np.sqrt(mean_squared_error(y_test, y_test_pred))
    train_r2 = r2_score(y_train, y_train_pred)
    test_r2 = r2_score(y_test, y_test_pred)
    
    # In kết quả
    print(f"Mô hình: {model_name}")
    print(f"Thời gian huấn luyện: {train_time:.2f} giây")
    print(f"Train MAE: {train_mae:.2f}, Test MAE: {test_mae:.2f}")
    print(f"Train RMSE: {train_rmse:.2f}, Test RMSE: {test_rmse:.2f}")
    print(f"Train R²: {train_r2:.4f}, Test R²: {test_r2:.4f}")
    print("-" * 50)
    
    # Trả về kết quả
    return {
        'model': model,
        'model_name': model_name,
        'train_time': train_time,
        'train_mae': train_mae,
        'test_mae': test_mae,
        'train_rmse': train_rmse,
        'test_rmse': test_rmse,
        'train_r2': train_r2,
        'test_r2': test_r2,
        'y_test': y_test,
        'y_test_pred': y_test_pred
    }

# Danh sách các mô hình để thử nghiệm
models = [
    (LinearRegression(), "Linear Regression"),
    (Ridge(alpha=0.5), "Ridge Regression"),
    (Lasso(alpha=0.1), "Lasso Regression"),
    (RandomForestRegressor(n_estimators=100, random_state=42), "Random Forest"),
    (GradientBoostingRegressor(n_estimators=100, random_state=42), "Gradient Boosting"),
    (xgb.XGBRegressor(n_estimators=100, random_state=42), "XGBoost"),
    (lgb.LGBMRegressor(n_estimators=100, random_state=42), "LightGBM")
]

# Đánh giá từng mô hình
results = []
for model, name in models:
    result = evaluate_model(model, X_train_processed, X_test_processed, y_train, y_test, name)
    results.append(result)

# Tìm mô hình tốt nhất dựa trên Test R²
best_model_idx = max(range(len(results)), key=lambda i: results[i]['test_r2'])
best_model_result = results[best_model_idx]
print(f"Mô hình tốt nhất: {best_model_result['model_name']} với Test R² = {best_model_result['test_r2']:.4f}")

# Lưu mô hình tốt nhất
joblib.dump(best_model_result['model'], 'best_revenue_prediction_model.pkl')
joblib.dump(preprocessor, 'revenue_preprocessor.pkl')

Trực quan hóa kết quả dự đoán

# Vẽ biểu đồ so sánh các mô hình
plt.figure(figsize=(12, 6))

# Tạo biểu đồ cột
model_names = [result['model_name'] for result in results]
test_r2 = [result['test_r2'] for result in results]
plt.bar(model_names, test_r2)
plt.title('So sánh hiệu suất các mô hình (Test R²)', fontsize=15)
plt.xlabel('Mô hình', fontsize=12)
plt.ylabel('R² Score', fontsize=12)
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig('model_comparison.png', dpi=300)
plt.show()

# Vẽ biểu đồ dự đoán vs giá trị thực tế cho mô hình tốt nhất
plt.figure(figsize=(12, 6))
plt.scatter(best_model_result['y_test'], best_model_result['y_test_pred'], alpha=0.5)
plt.plot([y_test.min(), y_test.max()], [y_test.min(), y_test.max()], 'r--')
plt.title('Giá trị thực tế vs Dự đoán (Mô hình tốt nhất)', fontsize=15)
plt.xlabel('Doanh thu thực tế', fontsize=12)
plt.ylabel('Doanh thu dự đoán', fontsize=12)
plt.tight_layout()
plt.savefig('actual_vs_predicted.png', dpi=300)
plt.show()

# Vẽ biểu đồ doanh thu thực tế và dự đoán theo thời gian
plt.figure(figsize=(15, 6))
daily_sales_test = daily_sales.iloc[-len(y_test):].copy()
daily_sales_test['Predicted_Revenue'] = best_model_result['y_test_pred']

plt.plot(daily_sales_test['OrderDate'], daily_sales_test['Revenue'], label='Doanh thu thực tế', marker='o', markersize=4)
plt.plot(daily_sales_test['OrderDate'], daily_sales_test['Predicted_Revenue'], label='Doanh thu dự đoán', marker='x', markersize=4)
plt.title('Doanh thu thực tế vs Dự đoán theo thời gian', fontsize=15)
plt.xlabel('Ngày', fontsize=12)
plt.ylabel('Doanh thu', fontsize=12)
plt.legend()
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.savefig('revenue_over_time.png', dpi=300)
plt.show()

Dự đoán doanh thu tương lai

Bây giờ chúng ta sẽ sử dụng mô hình đã huấn luyện để dự đoán doanh thu trong tương lai:

import datetime

# Tạo dữ liệu cho dự đoán tương lai
last_date = daily_sales['OrderDate'].max()
future_dates = pd.date_range(start=last_date + datetime.timedelta(days=1), periods=90)
future_data = pd.DataFrame({'OrderDate': future_dates})

# Thêm các tính năng thời gian
future_data['DayOfWeek'] = future_data['OrderDate'].dt.dayofweek
future_data['Month'] = future_data['OrderDate'].dt.month
future_data['Quarter'] = future_data['OrderDate'].dt.quarter
future_data['Year'] = future_data['OrderDate'].dt.year
future_data['IsWeekend'] = future_data['DayOfWeek'].apply(lambda x: 1 if x >= 5 else 0)

# Kết hợp với dữ liệu lịch sử để tính lag và rolling features
combined_data = pd.concat([
    daily_sales[['OrderDate', 'Revenue', 'Quantity']],
    future_data[['OrderDate']]
])
combined_data = combined_data.sort_values('OrderDate').reset_index(drop=True)

# Tính lag features
for lag in [1, 2, 3, 7, 14, 28]:
    combined_data[f'Revenue_Lag_{lag}'] = combined_data['Revenue'].shift(lag)
    combined_data[f'Quantity_Lag_{lag}'] = combined_data['Quantity'].shift(lag)

# Tính rolling features
for window in [7, 14, 30]:
    combined_data[f'Revenue_Rolling_{window}'] = combined_data['Revenue'].rolling(window=window).mean()
    combined_data[f'Quantity_Rolling_{window}'] = combined_data['Quantity'].rolling(window=window).mean()

# Lấy chỉ phần dữ liệu tương lai
future_with_features = combined_data[combined_data['OrderDate'].isin(future_dates)].copy()

# Fill NaN với giá trị trung bình
for col in future_with_features.columns:
    if col not in ['OrderDate', 'Revenue', 'Quantity'] and future_with_features[col].isnull().any():
        mean_value = daily_sales[col].mean()
        future_with_features[col] = future_with_features[col].fillna(mean_value)

# Chuẩn bị dữ liệu cho dự đoán
future_X = future_with_features.drop(['OrderDate', 'Revenue', 'Quantity'], axis=1)

# Nạp mô hình và preprocessor
best_model = joblib.load('best_revenue_prediction_model.pkl')
preprocessor = joblib.load('revenue_preprocessor.pkl')

# Tiền xử lý dữ liệu
future_X_processed = preprocessor.transform(future_X)

# Dự đoán
future_predictions = best_model.predict(future_X_processed)

# Thêm dự đoán vào future_data
future_data['Predicted_Revenue'] = future_predictions

# Trực quan hóa dự đoán tương lai
plt.figure(figsize=(15, 6))

# Vẽ doanh thu trong quá khứ
plt.plot(daily_sales['OrderDate'], daily_sales['Revenue'], label='Doanh thu quá khứ', color='blue')

# Vẽ dự đoán tương lai
plt.plot(future_data['OrderDate'], future_data['Predicted_Revenue'], 
         label='Dự đoán doanh thu', color='red', linestyle='--')

# Thêm vùng tin cậy (đơn giản, có thể cải thiện)
rmse = best_model_result['test_rmse']
plt.fill_between(
    future_data['OrderDate'],
    future_data['Predicted_Revenue'] - rmse,
    future_data['Predicted_Revenue'] + rmse,
    color='red',
    alpha=0.2,
    label='Khoảng tin cậy'
)

# Tùy chỉnh biểu đồ
plt.axvline(x=last_date, color='black', linestyle='--', label='Hiện tại')
plt.title('Dự đoán doanh thu 90 ngày tiếp theo', fontsize=15)
plt.xlabel('Ngày', fontsize=12)
plt.ylabel('Doanh thu', fontsize=12)
plt.legend()
plt.grid(True, linestyle='--', alpha=0.7)
plt.tight_layout()
plt.savefig('future_revenue_prediction.png', dpi=300)
plt.show()

# Lưu dự đoán vào SQL Server
future_data['PredictionDate'] = datetime.datetime.now()
future_data.to_sql('RevenuePredictions', engine, if_exists='replace', index=False)

Tự động hóa quy trình dự đoán

Để tự động hóa quy trình dự đoán hàng ngày, chúng ta có thể sử dụng APScheduler:

from apscheduler.schedulers.background import BlockingScheduler
import datetime
import pyodbc
import pandas as pd
from sqlalchemy import create_engine
import joblib
import urllib

def predict_revenue():
    print(f"Running revenue prediction at {datetime.datetime.now()}")
    
    # Kết nối đến SQL Server
    server = 'your_server_name'
    database = 'your_database_name'
    username = 'your_username'
    password = 'your_password'
    driver = '{ODBC Driver 17 for SQL Server}'
    
    conn_str = f'DRIVER={driver};SERVER={server};DATABASE={database};UID={username};PWD={password}'
    conn = pyodbc.connect(conn_str)
    quoted_conn_str = urllib.parse.quote_plus(conn_str)
    engine = create_engine(f'mssql+pyodbc:///?odbc_connect={quoted_conn_str}')
    
    # Truy vấn dữ liệu mới nhất
    query = """
    SELECT TOP 60
        OrderDate,
        SUM(Revenue) AS Revenue,
        SUM(Quantity) AS Quantity
    FROM 
        Sales
    GROUP BY 
        OrderDate
    ORDER BY 
        OrderDate DESC
    """
    
    historical_data = pd.read_sql(query, conn)
    historical_data = historical_data.sort_values('OrderDate').reset_index(drop=True)
    
    # Tạo dữ liệu cho dự đoán tương lai (30 ngày)
    last_date = historical_data['OrderDate'].max()
    future_dates = pd.date_range(start=last_date + datetime.timedelta(days=1), periods=30)
    future_data = pd.DataFrame({'OrderDate': future_dates})
    
    # Xử lý dữ liệu tương tự như đã làm ở trên...
    
    # Nạp mô hình và dự đoán...
    
    # Lưu dự đoán vào SQL Server
    future_data['PredictionDate'] = datetime.datetime.now()
    future_data.to_sql('RevenuePredictions', engine, if_exists='replace', index=False)
    
    print(f"Revenue prediction complete  engine, if_exists='replace', index=False)
    
    print(f"Revenue prediction completed and saved to database at {datetime.datetime.now()}")

# Tạo scheduler
scheduler = BlockingScheduler()

# Lên lịch chạy vào 1 giờ sáng mỗi ngày
scheduler.add_job(predict_revenue, 'cron', hour=1, minute=0)

# Chạy ngay lần đầu
predict_revenue()

# Bắt đầu scheduler
print("Starting scheduler...")
scheduler.start()

Xây dựng API đơn giản với Flask

Để các ứng dụng và hệ thống khác có thể truy cập vào dự đoán doanh thu, chúng ta có thể xây dựng một API đơn giản:

from flask import Flask, request, jsonify
import pandas as pd
import numpy as np
import joblib
import datetime

app = Flask(__name__)

# Nạp mô hình và preprocessor
best_model = joblib.load('best_revenue_prediction_model.pkl')
preprocessor = joblib.load('revenue_preprocessor.pkl')

@app.route('/predict', methods=['POST'])
def predict():
    try:
        # Lấy dữ liệu từ request
        data = request.get_json()
        
        # Kiểm tra dữ liệu đầu vào
        required_fields = ['start_date', 'num_days']
        for field in required_fields:
            if field not in data:
                return jsonify({'error': f'Missing required field: {field}'}), 400
        
        # Trích xuất tham số
        start_date = datetime.datetime.strptime(data['start_date'], '%Y-%m-%d')
        num_days = int(data['num_days'])
        
        if num_days > 365:
            return jsonify({'error': 'Maximum prediction period is 365 days'}), 400
        
        # Tạo dữ liệu ngày tháng
        future_dates = pd.date_range(start=start_date, periods=num_days)
        future_data = pd.DataFrame({'OrderDate': future_dates})
        
        # Xử lý dữ liệu tương tự như trên...
        
        # Dự đoán
        future_predictions = best_model.predict(future_X_processed)
        
        # Định dạng kết quả
        results = []
        for date, pred in zip(future_dates, future_predictions):
            results.append({
                'date': date.strftime('%Y-%m-%d'),
                'predicted_revenue': float(pred),
                'lower_bound': float(pred - rmse),
                'upper_bound': float(pred + rmse)
            })
        
        return jsonify({
            'status': 'success',
            'predictions': results,
            'model': best_model_result['model_name'],
            'rmse': float(rmse)
        })
        
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Tích hợp với Power BI

Để tạo bảng điều khiển trực quan cho các dự đoán doanh thu, chúng ta có thể kết nối Power BI trực tiếp với SQL Server để truy vấn bảng RevenuePredictions:

-- Truy vấn SQL có thể sử dụng trong Power BI
SELECT 
    rp.OrderDate,
    rp.Predicted_Revenue,
    rp.Predicted_Revenue - 1.96 * rm.RMSE AS LowerBound,
    rp.Predicted_Revenue + 1.96 * rm.RMSE AS UpperBound,
    s.Revenue AS ActualRevenue
FROM 
    RevenuePredictions rp
LEFT JOIN 
    (SELECT TOP 1 Value AS RMSE FROM ModelMetrics WHERE MetricName = 'RMSE') rm ON 1=1
LEFT JOIN 
    (SELECT OrderDate, SUM(Revenue) AS Revenue FROM Sales GROUP BY OrderDate) s 
    ON rp.OrderDate = s.OrderDate
ORDER BY 
    rp.OrderDate

Đánh giá và cải thiện mô hình

Để liên tục cải thiện mô hình dự đoán, chúng ta nên:

1. Theo dõi hiệu suất: So sánh dự đoán với doanh thu thực tế khi có dữ liệu mới
2. Tái huấn luyện định kỳ: Cập nhật mô hình với dữ liệu mới mỗi tuần hoặc mỗi tháng
3. Thử nghiệm tính năng mới: Thêm các yếu tố như dữ liệu marketing, dữ liệu kinh tế vĩ mô, thời tiết, v.v.
4. Thử nghiệm mô hình nâng cao: Như mạng thần kinh, mô hình dãy thời gian ARIMA, hoặc các mô hình kết hợp

# Mã ví dụ cho quá trình tái huấn luyện tự động
def retrain_model():
    # Lấy dữ liệu mới
    new_data = pd.read_sql("SELECT * FROM Sales", conn)
    
    # Xử lý dữ liệu
    
    # Huấn luyện mô hình
    
    # Đánh giá và lưu mô hình mới
    
    # Lưu metrics vào database
    metrics_df = pd.DataFrame({
        'MetricName': ['MAE', 'RMSE', 'R2'],
        'Value': [test_mae, test_rmse, test_r2],
        'UpdatedAt': [datetime.datetime.now()] * 3
    })
    metrics_df.to_sql('ModelMetrics', engine, if_exists='replace', index=False)

# Lên lịch tái huấn luyện mỗi tuần
scheduler.add_job(retrain_model, 'cron', day_of_week='mon', hour=2, minute=0)

Kết luận

Trong bài viết này, chúng ta đã tìm hiểu cách xây dựng một hệ thống dự đoán doanh thu tự động bằng cách kết hợp sức mạnh của SQL Server với các mô hình học máy Python. Hệ thống này có thể giúp doanh nghiệp:

1. Dự đoán doanh thu một cách chính xác cho các giai đoạn trong tương lai
2. Phát hiện xu hướng và mùa vụ trong dữ liệu bán hàng
3. Hỗ trợ lập kế hoạch về nguồn lực, kho hàng và ngân sách
4. Cải thiện ra quyết định dựa trên dữ liệu thay vì cảm tính

Quy trình này có thể được mở rộng để dự đoán các chỉ số kinh doanh khác như lợi nhuận, số lượng đơn hàng, hoặc thậm chí dự đoán cấp độ chi tiết hơn như doanh thu theo sản phẩm hoặc khu vực.

Hãy nhớ rằng việc dự đoán không bao giờ chính xác 100%, và mô hình cần được liên tục đánh giá và cải thiện khi có thêm dữ liệu mới. Tuy nhiên, với quy trình tự động này, bạn đã có một công cụ mạnh mẽ để hỗ trợ việc ra quyết định kinh doanh dựa trên dữ liệu.