Melatih dan mengevaluasi model prakiraan rangkaian waktu

Dalam buku catatan ini, kami membuat program untuk memperkirakan data rangkaian waktu yang memiliki siklus musiman. Kami menggunakan himpunan data Penjualan Properti NYC dengan tanggal mulai dari 2003 hingga 2015 yang diterbitkan oleh Departemen Keuangan NYC di Portal Data Terbuka NYC.

Prasyarat

• Dapatkan langganan Microsoft Fabric. Atau, daftar untuk uji coba Microsoft Fabric gratis.

• Masuk ke Microsoft Fabric.

• Gunakan pengalih pengalaman di sisi kiri halaman beranda Anda untuk beralih ke pengalaman Ilmu Data Synapse.

  

• Keakraban dengan notebook Microsoft Fabric.
• Lakehouse untuk menyimpan data untuk contoh ini. Untuk informasi selengkapnya, lihat Menambahkan lakehouse ke buku catatan Anda.

Ikuti di buku catatan

Anda bisa mengikuti di buku catatan salah satu dari dua cara:

• Buka dan jalankan notebook bawaan dalam pengalaman Ilmu Data Synapse.
• Unggah notebook Anda dari GitHub ke pengalaman Ilmu Data Synapse.

Buka buku catatan bawaan

Contoh notebook Seri waktu menyertai tutorial ini.

Untuk membuka buku catatan sampel bawaan tutorial dalam pengalaman Ilmu Data Synapse:

1. Buka halaman beranda Synapse Ilmu Data.

2. Pilih Gunakan sampel.

3. Pilih sampel yang sesuai:

   • Dari tab Alur kerja end-to-end (Python) default, jika sampelnya adalah untuk tutorial Python.
   • Dari tab Alur kerja end-to-end (R), jika sampelnya adalah untuk tutorial R.
   • Dari tab Tutorial cepat, jika sampel adalah untuk tutorial cepat.

4. Lampirkan lakehouse ke buku catatan sebelum Anda mulai menjalankan kode.

Mengimpor notebook dari GitHub

AIsample - Time Series Forecasting.ipynb adalah notebook yang menyertai tutorial ini.

Untuk membuka buku catatan yang menyertai tutorial ini, ikuti instruksi dalam Menyiapkan sistem Anda untuk tutorial ilmu data, untuk mengimpor buku catatan ke ruang kerja Anda.

Jika Anda lebih suka menyalin dan menempelkan kode dari halaman ini, Anda bisa membuat buku catatan baru.

Pastikan untuk melampirkan lakehouse ke buku catatan sebelum Anda mulai menjalankan kode.

Langkah 1: Menginstal pustaka kustom

Saat Anda mengembangkan model pembelajaran mesin, atau menangani analisis data ad-hoc, Anda mungkin perlu menginstal pustaka kustom dengan cepat (misalnya, prophet di buku catatan ini) untuk sesi Apache Spark. Untuk melakukan ini, Anda memiliki dua pilihan.

1. Anda dapat menggunakan kemampuan penginstalan sebaris (misalnya, , %pip, %condadll.) untuk memulai pustaka baru dengan cepat. Ini hanya akan menginstal pustaka kustom di buku catatan saat ini, bukan di ruang kerja.

# Use pip to install libraries
%pip install <library name>

# Use conda to install libraries
%conda install <library name>

2. Atau, Anda dapat membuat lingkungan Fabric, menginstal pustaka dari sumber publik atau mengunggah pustaka kustom ke dalamnya, dan kemudian admin ruang kerja Anda dapat melampirkan lingkungan sebagai default untuk ruang kerja. Semua pustaka di lingkungan kemudian akan tersedia untuk digunakan dalam notebook dan definisi pekerjaan Spark di ruang kerja. Untuk informasi selengkapnya tentang lingkungan, lihat membuat, mengonfigurasi, dan menggunakan lingkungan di Microsoft Fabric.

Untuk buku catatan ini, Anda gunakan %pip install untuk menginstal prophet pustaka. Kernel PySpark akan dimulai ulang setelah %pip install. Ini berarti Anda harus menginstal pustaka sebelum menjalankan sel lain.

# Use pip to install Prophet
%pip install prophet

Langkah 2: Muat data

Dataset

Notebook ini menggunakan himpunan data Penjualan Properti NYC. Ini mencakup data dari 2003 hingga 2015, yang diterbitkan oleh Departemen Keuangan NYC di Portal Data Terbuka NYC.

Himpunan data mencakup catatan setiap penjualan bangunan di pasar properti Kota New York, dalam periode 13 tahun. Lihat Glosarium Istilah untuk File Penjualan Properti untuk definisi kolom dalam himpunan data.

Borough	Lingkungan	building_class_category	tax_class	blokir	lot	timur	building_class_at_present	address	apartment_number	zip_code	residential_units	commercial_units	total_units	land_square_feet	gross_square_feet	year_built	tax_class_at_time_of_sale	building_class_at_time_of_sale	sale_price	sale_date
Manhattan	KOTA ALFABET	07 RENTALS - WALKUP APARTMENTS	0.0	384,0	17,0		C4	225 EAST 2ND STREET		10009.0	10.0	0.0	10.0	2145.0	6670.0	1900.0	2.0	C4	275000.0	2007-06-19
Manhattan	KOTA ALFABET	07 RENTALS - WALKUP APARTMENTS	2.0	405.0	12.0		C7	508 EAST 12TH STREET		10009.0	28,0	2.0	30.0	3872.0	15428.0	1930.0	2.0	C7	7794005.0	2007-05-21

Tujuannya adalah untuk membangun model yang memperkirakan total penjualan bulanan, berdasarkan data historis. Untuk ini, Anda menggunakan Prophet, pustaka prakiraan sumber terbuka yang dikembangkan oleh Facebook. Nabi didasarkan pada model aditif, di mana tren nonlinear cocok dengan musiman harian, mingguan, dan tahunan, dan efek liburan. Prophet bekerja paling baik pada himpunan data rangkaian waktu yang memiliki efek musiman yang kuat, dan beberapa musim data historis. Selain itu, Prophet dengan kuat menangani data yang hilang, dan outlier data.

Nabi menggunakan model rangkaian waktu yang dapat diurai, terdiri dari tiga komponen:

• tren: Nabi mengasumsikan tingkat pertumbuhan konstanta sepotong-bijaksana, dengan pemilihan titik perubahan otomatis
• musiman: Secara default, Nabi menggunakan Fourier Series agar sesuai dengan musiman mingguan dan tahunan
• hari libur: Nabi mengharuskan semua kejadian hari libur di masa lalu dan masa depan. Jika liburan tidak berulang di masa mendatang, Nabi tidak akan menyertakannya dalam prakiraan.

Buku catatan ini menggabungkan data setiap bulan, sehingga mengabaikan hari libur.

Baca makalah resmi untuk informasi lebih lanjut tentang teknik pemodelan Nabi.

Mengunduh himpunan data, dan mengunggah ke lakehouse

Sumber data terdiri dari 15 .csv file. File-file ini berisi catatan penjualan properti dari lima wilayah di New York, antara 2003 dan 2015. Untuk kenyamanan, nyc_property_sales.tar file menyimpan semua file ini .csv , mengompresinya ke dalam satu file. Penyimpanan blob yang tersedia untuk umum menghosting file ini .tar .

Tip

Dengan parameter yang diperlihatkan dalam sel kode ini, Anda dapat dengan mudah menerapkan buku catatan ini ke himpunan data yang berbeda.

URL = "https://synapseaisolutionsa.blob.core.windows.net/public/NYC_Property_Sales_Dataset/"
TAR_FILE_NAME = "nyc_property_sales.tar"
DATA_FOLDER = "Files/NYC_Property_Sales_Dataset"
TAR_FILE_PATH = f"/lakehouse/default/{DATA_FOLDER}/tar/"
CSV_FILE_PATH = f"/lakehouse/default/{DATA_FOLDER}/csv/"

EXPERIMENT_NAME = "aisample-timeseries" # MLflow experiment name

Kode ini mengunduh versi himpunan data yang tersedia untuk umum, lalu menyimpan himpunan data tersebut di Fabric Lakehouse.

Penting

Pastikan Anda menambahkan lakehouse ke buku catatan sebelum menjalankannya. Kegagalan untuk melakukannya akan mengakibatkan kesalahan.

import os

if not os.path.exists("/lakehouse/default"):
    # Add a lakehouse if the notebook has no default lakehouse
    # A new notebook will not link to any lakehouse by default
    raise FileNotFoundError(
        "Default lakehouse not found, please add a lakehouse for the notebook."
    )
else:
    # Verify whether or not the required files are already in the lakehouse, and if not, download and unzip
    if not os.path.exists(f"{TAR_FILE_PATH}{TAR_FILE_NAME}"):
        os.makedirs(TAR_FILE_PATH, exist_ok=True)
        os.system(f"wget {URL}{TAR_FILE_NAME} -O {TAR_FILE_PATH}{TAR_FILE_NAME}")

    os.makedirs(CSV_FILE_PATH, exist_ok=True)
    os.system(f"tar -zxvf {TAR_FILE_PATH}{TAR_FILE_NAME} -C {CSV_FILE_PATH}")

Mulai rekam run-time buku catatan ini.

# Record the notebook running time
import time

ts = time.time()

Menyiapkan pelacakan eksperimen MLflow

Untuk memperluas kemampuan pengelogan MLflow, autologging secara otomatis mengambil nilai parameter input dan metrik output model pembelajaran mesin selama pelatihannya. Informasi ini kemudian dicatat ke ruang kerja, di mana API MLflow atau eksperimen yang sesuai di ruang kerja dapat mengakses dan memvisualisasikannya. Kunjungi sumber daya ini untuk informasi selengkapnya tentang autologging.

# Set up the MLflow experiment
import mlflow

mlflow.set_experiment(EXPERIMENT_NAME)
mlflow.autolog(disable=True)  # Disable MLflow autologging

Catatan

Jika Anda ingin menonaktifkan autologging Microsoft Fabric dalam sesi notebook, panggil mlflow.autolog() dan atur disable=True.

Membaca data tanggal mentah dari lakehouse

df = (
    spark.read.format("csv")
    .option("header", "true")
    .load("Files/NYC_Property_Sales_Dataset/csv")
)

Langkah 3: Mulai analisis data eksploratif

Untuk meninjau himpunan data, Anda dapat memeriksa subset data secara manual untuk mendapatkan pemahaman yang lebih baik tentangnya. Anda dapat menggunakan display fungsi untuk mencetak DataFrame. Anda juga dapat menampilkan tampilan Bagan, untuk memvisualisasikan subset himpunan data dengan mudah.

display(df)

Tinjauan manual himpunan data mengarah ke beberapa pengamatan awal:

• Instans harga penjualan $0,00. Menurut Glosarium Ketentuan, ini menyiratkan transfer kepemilikan tanpa pertimbangan uang tunai. Dengan kata lain, tidak ada kas yang mengalir dalam transaksi. Anda harus menghapus penjualan dengan nilai $0,00 sales_price dari himpunan data.

• Himpunan data mencakup kelas bangunan yang berbeda. Namun, notebook ini akan berfokus pada bangunan perumahan yang, menurut Glosarium Istilah, ditandai sebagai jenis "A". Anda harus memfilter himpunan data untuk menyertakan hanya bangunan tempat tinggal. Untuk melakukan ini, sertakan building_class_at_time_of_sale kolom atau building_class_at_present . Anda hanya boleh menyertakan building_class_at_time_of_sale data.

• Himpunan data mencakup instans di mana total_units nilai sama dengan 0, atau gross_square_feet nilai sama dengan 0. Anda harus menghapus semua instans di mana total_units atau gross_square_units nilai sama dengan 0.

• Beberapa kolom - misalnya, apartment_number, , tax_class, build_class_at_presentdll. - memiliki nilai hilang atau NULL. Asumsikan bahwa data yang hilang melibatkan kesalahan klerikal, atau data yang tidak ada. Analisis tidak bergantung pada nilai yang hilang ini, sehingga Anda dapat mengabaikannya.

• Kolom sale_price disimpan sebagai string, dengan karakter "$" yang telah ditambahkan sebelumnya. Untuk melanjutkan analisis, mewakili kolom ini sebagai angka. Anda harus melemparkan sale_price kolom sebagai bilangan bulat.

Jenis konversi dan pemfilteran

Untuk mengatasi beberapa masalah yang diidentifikasi, impor pustaka yang diperlukan.

# Import libraries
import pyspark.sql.functions as F
from pyspark.sql.types import *

Transmisikan data penjualan dari string ke bilangan bulat

Gunakan ekspresi reguler untuk memisahkan bagian numerik string dari tanda dolar (misalnya, dalam string "$300.000", pisahkan "$" dan "300.000"), lalu transmisikan bagian numerik sebagai bilangan bulat.

Selanjutnya, filter data untuk hanya menyertakan instans yang memenuhi semua kondisi ini:

1. Lebih sales_price besar dari 0
2. Lebih total_units besar dari 0
3. Lebih gross_square_feet besar dari 0
4. building_class_at_time_of_sale tipe A

df = df.withColumn(
    "sale_price", F.regexp_replace("sale_price", "[$,]", "").cast(IntegerType())
)
df = df.select("*").where(
    'sale_price > 0 and total_units > 0 and gross_square_feet > 0 and building_class_at_time_of_sale like "A%"'
)

Agregasi setiap bulan

Sumber daya data melacak penjualan properti setiap hari, tetapi pendekatan ini terlalu terperinci untuk notebook ini. Sebagai gantinya, agregat data setiap bulan.

Pertama, ubah nilai tanggal untuk memperlihatkan hanya data bulan dan tahun. Nilai tanggal masih akan menyertakan data tahun. Anda masih dapat membedakan antara, misalnya, Desember 2005 dan Desember 2006.

Selain itu, hanya jaga agar kolom tetap relevan dengan analisis. Ini termasuk sales_price, total_units, gross_square_feet dan sales_date. Anda juga harus mengganti nama sales_date menjadi month.

monthly_sale_df = df.select(
    "sale_price",
    "total_units",
    "gross_square_feet",
    F.date_format("sale_date", "yyyy-MM").alias("month"),
)
display(monthly_sale_df)

Agregat sale_pricenilai , total_units dan gross_square_feet menurut bulan. Kemudian, kelompokkan data menurut month, dan jumlahkan semua nilai dalam setiap grup.

summary_df = (
    monthly_sale_df.groupBy("month")
    .agg(
        F.sum("sale_price").alias("total_sales"),
        F.sum("total_units").alias("units"),
        F.sum("gross_square_feet").alias("square_feet"),
    )
    .orderBy("month")
)

display(summary_df)

Konversi Pyspark ke Pandas

Pyspark DataFrames menangani himpunan data besar dengan baik. Namun, karena agregasi data, ukuran DataFrame lebih kecil. Ini menunjukkan bahwa Anda sekarang dapat menggunakan Pandas DataFrames.

Kode ini mentransmisikan himpunan data dari Pyspark DataFrame ke DataFrame pandas.

import pandas as pd

df_pandas = summary_df.toPandas()
display(df_pandas)

Visualisasi

Anda dapat memeriksa tren perdagangan properti New York City untuk lebih memahami data. Hal ini mengarah pada wawasan tentang pola potensial dan tren musiman. Pelajari selengkapnya tentang visualisasi data Microsoft Fabric di sumber daya ini .

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

f, (ax1, ax2) = plt.subplots(2, 1, figsize=(35, 10))
plt.sca(ax1)
plt.xticks(np.arange(0, 15 * 12, step=12))
plt.ticklabel_format(style="plain", axis="y")
sns.lineplot(x="month", y="total_sales", data=df_pandas)
plt.ylabel("Total Sales")
plt.xlabel("Time")
plt.title("Total Property Sales by Month")

plt.sca(ax2)
plt.xticks(np.arange(0, 15 * 12, step=12))
plt.ticklabel_format(style="plain", axis="y")
sns.lineplot(x="month", y="square_feet", data=df_pandas)
plt.ylabel("Total Square Feet")
plt.xlabel("Time")
plt.title("Total Property Square Feet Sold by Month")
plt.show()

Ringkasan pengamatan dari analisis data eksploratif

• Data menunjukkan pola berulang yang jelas pada irama tahunan; ini berarti data memiliki musiman tahunan
• Bulan-bulan musim panas tampaknya memiliki volume penjualan yang lebih tinggi dibandingkan dengan bulan-bulan musim dingin
• Dalam perbandingan tahun dengan penjualan tinggi dan tahun dengan penjualan rendah, perbedaan pendapatan antara bulan penjualan tinggi dan bulan penjualan rendah dalam tahun penjualan tinggi melebihi - dalam istilah absolut - perbedaan pendapatan antara bulan penjualan tinggi dan bulan penjualan rendah di tahun penjualan rendah.

Misalnya, pada tahun 2004, perbedaan pendapatan antara bulan penjualan tertinggi dan bulan penjualan terendah adalah tentang:

$900,000,000 - $500,000,000 = $400,000,000

Untuk 2011, perhitungan selisih pendapatan tersebut adalah tentang:

$400,000,000 - $300,000,000 = $100,000,000

Ini menjadi penting nanti, ketika Anda harus memutuskan antara efek musiman multiplikatif dan aditif .

Langkah 4: Pelatihan dan pelacakan model

Penyesuaian model

Input nabi selalu merupakan DataFrame dua kolom. Satu kolom input adalah kolom waktu bernama ds, dan satu kolom input adalah kolom nilai bernama y. Kolom waktu harus memiliki format data tanggal, waktu, atau tanggalwaktu (misalnya, YYYY_MM). Himpunan data di sini memenuhi kondisi tersebut. Kolom nilai harus berupa format data numerik.

Untuk penyesuaian model, Anda hanya boleh mengganti nama kolom waktu menjadi kolom nilai menjadi dsy, dan meneruskan data ke Nabi. Baca dokumentasi PROPHET Python API untuk informasi selengkapnya.

df_pandas["ds"] = pd.to_datetime(df_pandas["month"])
df_pandas["y"] = df_pandas["total_sales"]

Nabi mengikuti konvensi scikit-learn . Pertama, buat instans Baru Nabi, atur parameter tertentu (misalnya,seasonality_mode), lalu paskan instans tersebut ke himpunan data.

• Meskipun faktor aditif yang konstan adalah efek musiman default untuk Prophet, Anda harus menggunakan musiman 'multiplikatif' untuk parameter efek musiman. Analisis di bagian sebelumnya menunjukkan bahwa karena perubahan amplitude musiman, musiman aditif sederhana tidak akan sesuai dengan data dengan baik sama sekali.

• Atur parameter weekly_seasonality ke nonaktif, karena data dikumpulkan berdasarkan bulan. Akibatnya, data mingguan tidak tersedia.

• Gunakan metode Markov Chain Monte Carlo (MCMC) untuk menangkap perkiraan ketidakpastian musiman. Secara default, Nabi dapat memberikan perkiraan ketidakpastian tentang kebisingan tren dan pengamatan, tetapi tidak untuk musiman. MCMC membutuhkan lebih banyak waktu pemrosesan, tetapi mereka memungkinkan algoritma untuk memberikan perkiraan ketidakpastian pada musiman, dan kebisingan tren dan pengamatan. Baca dokumentasi Interval Ketidakpastian Nabi untuk informasi lebih lanjut.

• Sesuaikan sensitivitas deteksi titik perubahan otomatis melalui parameter changepoint_prior_scale . Algoritma Nabi secara otomatis mencoba menemukan instans dalam data tempat lintasan tiba-tiba berubah. Ini bisa menjadi sulit untuk menemukan nilai yang benar. Untuk mengatasinya, Anda dapat mencoba nilai yang berbeda lalu memilih model dengan performa terbaik. Baca dokumentasi Prophet Trend Changepoints untuk informasi selengkapnya.

from prophet import Prophet

def fit_model(dataframe, seasonality_mode, weekly_seasonality, chpt_prior, mcmc_samples):
    m = Prophet(
        seasonality_mode=seasonality_mode,
        weekly_seasonality=weekly_seasonality,
        changepoint_prior_scale=chpt_prior,
        mcmc_samples=mcmc_samples,
    )
    m.fit(dataframe)
    return m

Validasi silang

Prophet memiliki alat validasi silang bawaan. Alat ini dapat memperkirakan kesalahan prakiraan, dan menemukan model dengan performa terbaik.

Teknik validasi silang dapat memvalidasi efisiensi model. Teknik ini melatih model pada subkumpulan himpunan data, dan menjalankan pengujian pada subset himpunan data yang sebelumnya tidak diketahui. Teknik ini dapat memeriksa seberapa baik model statistik digeneralisasi ke himpunan data independen.

Untuk validasi silang, pesan sampel himpunan data tertentu, yang bukan bagian dari himpunan data pelatihan. Kemudian, uji model terlatih pada sampel tersebut, sebelum penyebaran. Namun, pendekatan ini tidak berfungsi untuk data rangkaian waktu, karena jika model telah melihat data dari bulan Januari 2005 dan Maret 2005, dan Anda mencoba memprediksi untuk bulan Februari 2005, model pada dasarnya dapat curang, karena dapat melihat ke mana tren data mengarah. Dalam aplikasi nyata, tujuannya adalah untuk memperkirakan masa depan, sebagai wilayah yang tidak jelas.

Untuk menangani ini, dan membuat pengujian dapat diandalkan, pisahkan himpunan data berdasarkan tanggal. Gunakan himpunan data hingga tanggal tertentu (misalnya, data 11 tahun pertama) untuk pelatihan, lalu gunakan data yang tidak disembunyikan yang tersisa untuk prediksi.

Dalam skenario ini, mulailah dengan data pelatihan selama 11 tahun, lalu buat prediksi bulanan menggunakan cakrawala satu tahun. Secara khusus, data pelatihan berisi semuanya dari 2003 hingga 2013. Kemudian, eksekusi pertama menangani prediksi untuk Januari 2014 hingga Januari 2015. Eksekusi berikutnya menangani prediksi untuk Februari 2014 hingga Februari 2015, dan sebagainya.

Ulangi proses ini untuk masing-masing dari tiga model terlatih, untuk melihat model mana yang berkinerja terbaik. Kemudian, bandingkan prediksi ini dengan nilai dunia nyata, untuk menetapkan kualitas prediksi model terbaik.

from prophet.diagnostics import cross_validation
from prophet.diagnostics import performance_metrics

def evaluation(m):
    df_cv = cross_validation(m, initial="4017 days", period="30 days", horizon="365 days")
    df_p = performance_metrics(df_cv, monthly=True)
    future = m.make_future_dataframe(periods=12, freq="M")
    forecast = m.predict(future)
    return df_p, future, forecast

Model log dengan MLflow

Catat model, untuk melacak parameternya, dan simpan model untuk digunakan nanti. Semua informasi model yang relevan dicatat di ruang kerja, di bawah nama eksperimen. Model, parameter, dan metrik, bersama dengan item autologging MLflow, disimpan dalam satu eksekusi MLflow.

# Setup MLflow
from mlflow.models.signature import infer_signature

Melakukan eksperimen

Eksperimen pembelajaran mesin berfungsi sebagai unit utama organisasi dan kontrol, untuk semua eksekusi pembelajaran mesin terkait. Eksekusi sesuai dengan satu eksekusi kode model. Pelacakan eksperimen pembelajaran mesin mengacu pada manajemen semua eksperimen yang berbeda dan komponennya. Ini termasuk parameter, metrik, model, dan artefak lainnya, dan membantu mengatur komponen yang diperlukan dari eksperimen pembelajaran mesin tertentu. Pelacakan eksperimen pembelajaran mesin juga memungkinkan duplikasi hasil sebelumnya yang mudah dengan eksperimen yang disimpan. Pelajari selengkapnya tentang eksperimen pembelajaran mesin di Microsoft Fabric. Setelah Anda menentukan langkah-langkah yang ingin Anda sertakan (misalnya, mencocokkan dan mengevaluasi model Nabi dalam buku catatan ini), Anda dapat menjalankan eksperimen.

model_name = f"{EXPERIMENT_NAME}-prophet"

models = []
df_metrics = []
forecasts = []
seasonality_mode = "multiplicative"
weekly_seasonality = False
changepoint_priors = [0.01, 0.05, 0.1]
mcmc_samples = 100

for chpt_prior in changepoint_priors:
    with mlflow.start_run(run_name=f"prophet_changepoint_{chpt_prior}"):
        # init model and fit
        m = fit_model(df_pandas, seasonality_mode, weekly_seasonality, chpt_prior, mcmc_samples)
        models.append(m)
        # Validation
        df_p, future, forecast = evaluation(m)
        df_metrics.append(df_p)
        forecasts.append(forecast)
        # Log model and parameters with MLflow
        mlflow.prophet.log_model(
            m,
            model_name,
            registered_model_name=model_name,
            signature=infer_signature(future, forecast),
        )
        mlflow.log_params(
            {
                "seasonality_mode": seasonality_mode,
                "mcmc_samples": mcmc_samples,
                "weekly_seasonality": weekly_seasonality,
                "changepoint_prior": chpt_prior,
            }
        )
        metrics = df_p.mean().to_dict()
        metrics.pop("horizon")
        mlflow.log_metrics(metrics)

Memvisualisasikan model dengan Nabi

Prophet memiliki fungsi visualisasi bawaan, yang dapat menunjukkan hasil pas model.

Titik-titik hitam menunjukkan titik data yang digunakan untuk melatih model. Garis biru adalah prediksi, dan area biru muda menunjukkan interval ketidakpastian. Anda telah membangun tiga model dengan nilai yang berbeda changepoint_prior_scale . Prediksi ketiga model ini ditampilkan dalam hasil blok kode ini.

for idx, pack in enumerate(zip(models, forecasts)):
    m, forecast = pack
    fig = m.plot(forecast)
    fig.suptitle(f"changepoint = {changepoint_priors[idx]}")

Nilai terkecil changepoint_prior_scale dalam grafik pertama menyebabkan kurangnya perubahan tren. Grafik terbesar changepoint_prior_scale dalam grafik ketiga dapat mengakibatkan overfitting. Jadi, grafik kedua tampaknya menjadi pilihan optimal. Ini menyiratkan bahwa model kedua adalah yang paling cocok.

Memvisualisasikan tren dan musiman dengan Nabi

Nabi juga dapat dengan mudah memvisualisasikan tren dan musiman yang mendasar. Visualisasi model kedua ditampilkan dalam hasil blok kode ini.

BEST_MODEL_INDEX = 1  # Set the best model index according to the previous results
fig2 = models[BEST_MODEL_INDEX].plot_components(forecast)

Dalam grafik ini, bayangan biru muda mencerminkan ketidakpastian. Grafik teratas menunjukkan tren berosilasi periode panjang yang kuat. Selama beberapa tahun, volume penjualan naik dan turun. Grafik yang lebih rendah menunjukkan bahwa penjualan cenderung memuncak pada bulan Februari dan September, mencapai nilai maksimumnya untuk tahun tersebut pada bulan-bulan tersebut. Tak lama setelah bulan-bulan tersebut, pada bulan Maret dan Oktober, nilai tersebut jatuh ke nilai minimum tahun ini.

Evaluasi performa model menggunakan berbagai metrik, misalnya:

• kesalahan kuadrat rata-rata (MSE)
• kesalahan kuadrat rata-rata akar (RMSE)
• kesalahan absolut rata-rata (MAE)
• kesalahan persen absolut rata-rata (MAPE)
• kesalahan persen absolut median (MDAPE)
• kesalahan persentase absolut rata-rata simetris (SMAPE)

Evaluasi cakupan menggunakan yhat_lower perkiraan dan yhat_upper . Perhatikan cakrawala yang bervariasi di mana Anda memprediksi satu tahun di masa depan, 12 kali.

display(df_metrics[BEST_MODEL_INDEX])

Dengan metrik MAPE, untuk model prakiraan ini, prediksi yang diperpanjang satu bulan ke depan biasanya melibatkan kesalahan sekitar 8%. Namun, untuk prediksi satu tahun ke depan, kesalahan meningkat menjadi sekitar 10%.

Langkah 5: Menilai model dan menyimpan hasil prediksi

Sekarang nilai model, dan simpan hasil prediksi.

Membuat prediksi dengan Predict Transformer

Sekarang, Anda dapat memuat model dan menggunakannya untuk membuat prediksi. Pengguna dapat mengoprasikan model pembelajaran mesin dengan PREDICT, fungsi Microsoft Fabric yang dapat diskalakan yang mendukung penilaian batch di mesin komputasi apa pun. Pelajari selengkapnya tentang PREDICT, dan cara menggunakannya dalam Microsoft Fabric, di sumber daya ini.

from synapse.ml.predict import MLFlowTransformer

spark.conf.set("spark.synapse.ml.predict.enabled", "true")

model = MLFlowTransformer(
    inputCols=future.columns.values,
    outputCol="prediction",
    modelName=f"{EXPERIMENT_NAME}-prophet",
    modelVersion=BEST_MODEL_INDEX,
)

test_spark = spark.createDataFrame(data=future, schema=future.columns.to_list())

batch_predictions = model.transform(test_spark)

display(batch_predictions)

# Code for saving predictions into lakehouse
batch_predictions.write.format("delta").mode("overwrite").save(
    f"{DATA_FOLDER}/predictions/batch_predictions"
)

# Determine the entire runtime
print(f"Full run cost {int(time.time() - ts)} seconds.")

Konten terkait

• Model pembelajaran mesin di Microsoft Fabric
• Melatih model pembelajaran mesin
• Eksperimen pembelajaran mesin di Microsoft Fabric