ทดสอบและประเมินแบบจําลองการคาดการณ์อนุกรมเวลา

ในสมุดบันทึกนี้ เราสร้างโปรแกรมการพยากรณ์ชุดข้อมูลเวลาที่มีรอบการทํางานตามฤดูกาล เราใช้ชุดข้อมูลยอดขายของคุณสมบัติ NYC ที่มีวันที่ตั้งแต่ปี 2003 ถึง 2015 ที่เผยแพร่โดยแผนกการเงินของ NYC บนพอร์ทัลข้อมูลเปิดของ NYC

ข้อกำหนดเบื้องต้น

• รับการสมัครใช้งาน Microsoft Fabric หรือลงทะเบียนเพื่อทดลองใช้งาน Microsoft Fabric ฟรี

• ลงชื่อเข้าใช้ Microsoft Fabric

• ใช้ตัวสลับประสบการณ์ทางด้านซ้ายของโฮมเพจของคุณเพื่อสลับไปยังประสบการณ์วิทยาศาสตร์ข้อมูล Synapse

  

• ความคุ้นเคยกับ สมุดบันทึก Microsoft Fabric
• เลคเฮ้าส์สําหรับจัดเก็บข้อมูลสําหรับตัวอย่างนี้ สําหรับข้อมูลเพิ่มเติม ดู เพิ่มเลคเฮาส์ลงในสมุดบันทึกของคุณ

ติดตามในสมุดบันทึก

คุณสามารถทําตามในสมุดบันทึกได้สองวิธี:

• เปิดและเรียกใช้สมุดบันทึกที่มีอยู่ภายในในประสบการณ์วิทยาศาสตร์ข้อมูล Synapse
• อัปโหลดสมุดบันทึกของคุณจาก GitHub ไปยังประสบการณ์วิทยาศาสตร์ข้อมูล Synapse

เปิดสมุดบันทึกที่มีอยู่แล้วภายใน

ตัวอย่าง สมุดบันทึกชุดข้อมูล เวลาจะมาพร้อมกับบทช่วยสอนนี้

เมื่อต้องการเปิดสมุดบันทึกตัวอย่างที่มีอยู่แล้วภายในของบทช่วยสอนในประสบการณ์ Synapse Data Science:

1. ไปที่หน้าแรกของ Synapse Data Science

2. เลือก ใช้ตัวอย่าง

3. เลือกตัวอย่างที่สอดคล้องกัน:

   • จากแท็บ เวิร์กโฟลว์แบบ End-to-end (Python) ตามค่าเริ่มต้น ถ้าตัวอย่างมีไว้สําหรับบทช่วยสอน Python
   • จากแท็บ เวิร์กโฟลว์แบบครอบคลุม (R) ถ้าตัวอย่างมีไว้สําหรับบทช่วยสอน R
   • จากแท็บ บทช่วยสอน ด่วน ถ้าตัวอย่างมีไว้สําหรับบทช่วยสอนด่วน

4. แนบเลคเฮ้าส์ลงในสมุดบันทึก ก่อนที่คุณจะเริ่มเรียกใช้โค้ด

นําเข้าสมุดบันทึกจาก GitHub

AIsample - Time Series Forecasting.ipynb คือสมุดบันทึกที่มาพร้อมกับบทช่วยสอนนี้

เมื่อต้องการเปิดสมุดบันทึกที่มาพร้อมกับบทช่วยสอนนี้ ให้ทําตามคําแนะนําใน เตรียมระบบของคุณสําหรับบทช่วยสอนวิทยาศาสตร์ข้อมูล เพื่อนําเข้าสมุดบันทึกไปยังพื้นที่ทํางานของคุณ

ถ้าคุณต้องการคัดลอกและวางรหัสจากหน้านี้แทน คุณสามารถสร้าง สมุดบันทึกใหม่ได้

ตรวจสอบให้แน่ใจว่าแนบ lakehouse เข้ากับสมุดบันทึก ก่อนที่คุณจะเริ่มเรียกใช้รหัส

ขั้นตอนที่ 1: ติดตั้งไลบรารีแบบกําหนดเอง

เมื่อคุณพัฒนาแบบจําลองการเรียนรู้ของเครื่อง หรือคุณจัดการการวิเคราะห์ข้อมูลเฉพาะกิจ คุณอาจจําเป็นต้องติดตั้งไลบรารีแบบกําหนดเอง (ตัวอย่างเช่น prophet ในสมุดบันทึกนี้) สําหรับเซสชัน Apache Spark ได้อย่างรวดเร็ว เมื่อต้องการทําเช่นนี้คุณมีสองตัวเลือก

1. คุณสามารถใช้ความสามารถในการติดตั้งในบรรทัด (ตัวอย่างเช่น %pip, %conda, ฯลฯ) เพื่อเริ่มต้นใช้งานไลบรารีใหม่อย่างรวดเร็ว ซึ่งจะติดตั้งไลบรารีแบบกําหนดเองในสมุดบันทึกปัจจุบันเท่านั้น ไม่ใช่ในพื้นที่ทํางาน

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

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

2. อีกวิธีหนึ่งคือ คุณสามารถสร้างสภาพแวดล้อม Fabric ติดตั้งไลบรารีจากแหล่งข้อมูลสาธารณะ หรืออัปโหลดไลบรารีแบบกําหนดเอง จากนั้นผู้ดูแลระบบพื้นที่ทํางานของคุณสามารถแนบสภาพแวดล้อมเป็นค่าเริ่มต้นสําหรับพื้นที่ทํางานได้ ไลบรารีทั้งหมดในสภาพแวดล้อมจะพร้อมใช้งานสําหรับใช้ในข้อกําหนดงานของสมุดบันทึกและ Spark ในพื้นที่ทํางาน สําหรับข้อมูลเพิ่มเติมเกี่ยวกับสภาพแวดล้อม ดูสร้าง กําหนดค่า และใช้สภาพแวดล้อมใน Microsoft Fabric

สําหรับสมุดบันทึกนี้ คุณใช้ %pip install เพื่อติดตั้ง prophet ไลบรารี เคอร์เนล PySpark จะเริ่มต้นใหม่หลังจาก%pip install ซึ่งหมายความว่าคุณต้องติดตั้งไลบรารีก่อนที่จะเรียกใช้เซลล์อื่นๆ

# Use pip to install Prophet
%pip install prophet

ขั้นตอนที่ 2: โหลดข้อมูล

ชุดข้อมูล

สมุดบันทึกนี้ใช้ชุดข้อมูลยอดขายของคุณสมบัติ NYC ครอบคลุมข้อมูลจากปี 2003 ถึงปี 2015 ซึ่งเผยแพร่โดยแผนกการเงินของ NYC ในพอร์ทัลข้อมูลเปิดของ NYC

ชุดข้อมูลประกอบด้วยบันทึกของการขายทุกรุ่นในตลาดทรัพย์สินของนิวยอร์กซิตี้ภายในระยะเวลา 13 ปี ดูอภิธานศัพท์สําหรับไฟล์ยอดขายคุณสมบัติสําหรับข้อกําหนดของคอลัมน์ในชุดข้อมูล

เป้าหมายคือการสร้างแบบจําลองที่คาดการณ์ยอดขายทั้งหมดรายเดือนตามข้อมูลในอดีต สําหรับเรื่องนี้คุณใช้ศาสดาพยากรณ์ไลบรารีการคาดการณ์โอเพนซอร์ส (Open Source)พัฒนาขึ้นโดย Facebook ศาสดาพยากรณ์ยึดตามแบบจําลองเสริม ซึ่งแนวโน้มที่ไม่ใช่เชิงเส้นจะพอดีกับฤดูกาลรายวัน รายสัปดาห์ และรายปี และผลกระทบวันหยุด ศาสดาพยากรณ์ทํางานได้ดีที่สุดในชุดข้อมูลเวลาที่มีผลกระทบตามฤดูกาลที่แข็งแกร่ง และมีหลายฤดูกาลของข้อมูลในอดีต นอกจากนี้ ศาสดาพยากรณ์ยังจัดการกับข้อมูลที่ขาดหายไป และข้อมูลที่ผิดปกติ

ศาสดาพยากรณ์ใช้แบบจําลองชุดข้อมูลเวลาที่สามารถย่อยสลายได้ ซึ่งประกอบด้วยคอมโพเนนต์สามอย่าง:

• trend: Prophet สันนิษฐานว่าจํานวนการเติบโตคงที่ตามจํานวนชิ้น โดยมีการเลือกจุดการเปลี่ยนแปลงโดยอัตโนมัติ
• กาล: ตามค่าเริ่มต้น ศาสดาพยากรณ์ใช้โฟร์เยอร์ซีรี่ส์เพื่อให้เหมาะกับกาลรายสัปดาห์และรายปี
• วันหยุด: ศาสดาพยากรณ์ต้องการการปรากฏของวันหยุดในอดีตและอนาคตทั้งหมด หากวันหยุดไม่ซ้ํากันในอนาคต ศาสดาพยากรณ์จะไม่รวมไว้ในการพยากรณ์

สมุดบันทึกนี้รวมข้อมูลเป็นรายเดือน ดังนั้นจึงละเว้นวันหยุด

อ่าน เอกสาร อย่างเป็นทางการสําหรับข้อมูลเพิ่มเติมเกี่ยวกับเทคนิคการสร้างแบบจําลองโดยศาสดาพยากรณ์

ดาวน์โหลดชุดข้อมูลและอัปโหลดไปยังเลคเฮ้าส์

แหล่งข้อมูลประกอบด้วยไฟล์ 15 .csv ไฟล์ ไฟล์เหล่านี้ประกอบด้วยบันทึกยอดขายคุณสมบัติจากห้า boroughs ในนิวยอร์กระหว่างปี 2003 และ 2015 เพื่อความสะดวก nyc_property_sales.tar ไฟล์เก็บไฟล์ทั้งหมดเหล่านี้ .csv บีบอัดเป็นไฟล์เดียว ที่เก็บข้อมูล blob ที่พร้อมใช้งานสาธารณะจะโฮสต์ไฟล์นี้.tar

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

รหัสนี้จะดาวน์โหลดเวอร์ชันสาธารณะของชุดข้อมูล และจากนั้นจัดเก็บชุดข้อมูลนั้นใน Fabric Lakehouse

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}")

เริ่มการบันทึกเวลาทํางานของสมุดบันทึกนี้

# Record the notebook running time
import time

ts = time.time()

ตั้งค่าการติดตามการทดสอบ MLflow

เพื่อขยายความสามารถในการบันทึกกระแส ML การล็อกอัตโนมัติจะจับค่าของพารามิเตอร์อินพุตและเมตริกเอาท์พุตของแบบจําลองการเรียนรู้ของเครื่องในระหว่างการฝึกโดยอัตโนมัติ ข้อมูลนี้จะถูกบันทึกไปยังพื้นที่ทํางานที่ MLflow API หรือการทดลองที่สอดคล้องกันในพื้นที่ทํางานสามารถเข้าถึงและแสดงภาพได้ เยี่ยมชม แหล่งข้อมูล นี้สําหรับข้อมูลเพิ่มเติมเกี่ยวกับการล็อกอัตโนมัติ

# Set up the MLflow experiment
import mlflow

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

อ่านข้อมูลวันที่ดิบจากเลคเฮ้าส์

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

ขั้นตอนที่ 3: เริ่มการวิเคราะห์ข้อมูลเชิงสํารวจ

หากต้องการตรวจสอบชุดข้อมูล คุณสามารถตรวจสอบชุดย่อยของข้อมูลด้วยตนเองเพื่อให้เข้าใจมากขึ้น คุณสามารถใช้ display ฟังก์ชันเพื่อพิมพ์ DataFrame ได้ คุณยังสามารถแสดงมุมมองแผนภูมิ เพื่อแสดงชุดย่อยของชุดข้อมูลได้อย่างง่ายดาย

display(df)

การตรวจทานชุดข้อมูลด้วยตนเองนําไปสู่ข้อสังเกตบางอย่างในช่วงแรก:

• อินสแตนซ์ของราคาขาย $0.00 อภิธานศัพท์ตามเงื่อนไขนี้หมายถึงการโอนความเป็นเจ้าของโดยไม่มีการพิจารณาเงินสด กล่าวอีกนัยหนึ่งคือ ไม่มีกระแสเงินสดในธุรกรรม คุณควรลบยอดขายออกด้วยค่า $0.00 sales_price จากชุดข้อมูล

• ชุดข้อมูลครอบคลุมถึงระดับอาคารที่แตกต่างกัน อย่างไรก็ตามสมุดบันทึกนี้จะมุ่งเน้นไปที่อาคารที่อยู่อาศัยซึ่งตาม อภิธานศัพท์มีการทําเครื่องหมายเป็นชนิด "A" คุณควรกรองชุดข้อมูลเพื่อรวมเฉพาะอาคารพักอาศัยเท่านั้น เมื่อต้องการทําเช่นนี้ ให้รวม หรือ building_class_at_time_of_sale building_class_at_present คอลัมน์ คุณต้องรวม building_class_at_time_of_sale ข้อมูลเท่านั้น

• ชุดข้อมูลประกอบด้วยอินสแตนซ์ที่ total_units ค่าเท่ากับ 0 หรือ gross_square_feet ค่าเท่ากับ 0 คุณควรลบอินสแตนซ์ทั้งหมดที่หรือtotal_unitsgross_square_unitsค่าเท่ากับ 0

• บางคอลัมน์ - ตัวอย่างเช่น apartment_number, tax_class, build_class_at_present, ฯลฯ - มีค่า NULL ขาดหายไปหรือ สมมติว่าข้อมูลที่ขาดหายไปนั้นเกี่ยวข้องกับข้อผิดพลาดทางการจัดการหรือข้อมูลที่ไม่มีอยู่ การวิเคราะห์ไม่ได้ขึ้นอยู่กับค่าที่หายไปเหล่านี้ ดังนั้นคุณสามารถเพิกเฉยได้

• คอลัมน์ sale_price ถูกจัดเก็บเป็นสตริงที่มีอักขระ "$" ที่นําหน้า หากต้องการดําเนินการวิเคราะห์ ต่อไป ให้แสดงคอลัมน์นี้เป็นตัวเลข คุณควรแคสต์ sale_price คอลัมน์เป็นจํานวนเต็ม

การแปลงชนิดและการกรอง

เมื่อต้องการแก้ไขปัญหาที่ระบุบางส่วน ให้นําเข้าไลบรารีที่จําเป็น

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

แคสต์ข้อมูลยอดขายจากสตริงเป็นจํานวนเต็ม

ใช้นิพจน์ปกติเพื่อแยกส่วนตัวเลขของสตริงจากเครื่องหมายดอลลาร์ (ตัวอย่างเช่น ในสตริง $300,000แยก $ และ 300,000) แล้วแปลงส่วนตัวเลขเป็นจํานวนเต็ม

ถัดไป กรองข้อมูลเพื่อรวมเฉพาะอินสแตนซ์ที่ตรงตามเงื่อนไขเหล่านี้ทั้งหมด:

1. มากกว่า sales_price 0
2. มากกว่า total_units 0
3. มากกว่า gross_square_feet 0
4. building_class_at_time_of_saleเป็นชนิด 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%"'
)

การรวมข้อมูลเป็นรายเดือน

ทรัพยากรข้อมูลจะติดตามยอดขายของคุณสมบัติในแต่ละวัน แต่วิธีนี้แยกย่อยเกินไปสําหรับสมุดบันทึกนี้ แต่ให้รวมข้อมูลเป็นรายเดือนแทน

ก่อนอื่น เปลี่ยนค่าวันที่เพื่อแสดงเฉพาะข้อมูลเดือนและปี ค่าวันที่จะยังคงมีข้อมูลปี คุณยังคงสามารถแยกความแตกต่างระหว่างได้ ตัวอย่างเช่น ธันวาคม 2005 และธันวาคม 2006

นอกจากนี้ เก็บเฉพาะคอลัมน์ที่เกี่ยวข้องกับการวิเคราะห์ ซึ่งรวมถึง sales_price, total_unitsgross_square_feet และsales_date นอกจากนี้ คุณยังต้องเปลี่ยนชื่อsales_dateเป็น อีกด้วย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)

รวม sale_priceค่า , total_units และ gross_square_feet ตามเดือน จากนั้นจัดกลุ่มข้อมูลตาม monthและรวมค่าทั้งหมดภายในแต่ละกลุ่ม

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)

การแปลง Pyspark เป็น Pandas

Pyspark DataFrames จัดการชุดข้อมูลขนาดใหญ่ได้ดี อย่างไรก็ตาม เนื่องจากการรวมข้อมูล ขนาดของ DataFrame จึงเล็กลง ซึ่งแสดงให้เห็นว่าตอนนี้คุณสามารถใช้ DataFrame ของ pandas ได้แล้ว

รหัสนี้จะแปลงชุดข้อมูลจาก pyspark DataFrame ไปยัง pandas DataFrame

import pandas as pd

df_pandas = summary_df.toPandas()
display(df_pandas)

การแสดงภาพ

คุณสามารถตรวจสอบแนวโน้มการค้าทรัพย์สินของนิวยอร์กซิตี้เพื่อทําความเข้าใจข้อมูลได้ดียิ่งขึ้น ซึ่งนําไปสู่ข้อมูลเชิงลึกของรูปแบบที่เป็นไปได้และแนวโน้มตามฤดูกาล เรียนรู้เพิ่มเติมเกี่ยวกับการแสดงภาพข้อมูล Microsoft Fabric ที่ทรัพยากรนี้

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()

ข้อมูลสรุปของการสังเกตการณ์จากการวิเคราะห์ข้อมูลการสํารวจ

• ข้อมูลแสดงรูปแบบการเกิดซ้ําที่ชัดเจนในจังหวะรายปี ซึ่งหมายความว่าข้อมูลมี กาลต่อปี
• เดือนในฤดูร้อนดูเหมือนจะมีปริมาณยอดขายที่สูงขึ้นเมื่อเทียบกับเดือนฤดูหนาว
• ในการเปรียบเทียบของปีกับยอดขายสูงและปีที่มียอดขายต่ํา ความแตกต่างของรายได้ระหว่างเดือนที่ขายสูงและเดือนที่ขายต่ําในปีที่มียอดขายสูงเกินกว่า - ในแง่สัมบูรณ์ - ความแตกต่างของรายได้ระหว่างเดือนที่มียอดขายสูงและเดือนที่มียอดขายต่ําในปีที่ขายต่ํา

ตัวอย่างเช่น ในปี 2004 ความแตกต่างของรายได้ระหว่างเดือนที่ขายสูงสุดและเดือนที่ขายต่ําสุดเป็นเรื่องเกี่ยวกับ:

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

สําหรับปี 2011 การคํานวณผลต่างรายได้ที่เกี่ยวกับ:

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

สิ่งนี้กลายเป็นสิ่งสําคัญในภายหลังเมื่อคุณต้องตัดสินใจระหว่างผลกระทบฤดูกาลคูณและบวก

ขั้นตอนที่ 4: การฝึกอบรมและการติดตามแบบจําลอง

ข้อต่อแบบจําลอง

การป้อนข้อมูลของศาสดาพยากรณ์ มักจะเป็น DataFrame แบบสองคอลัมน์ คอลัมน์อินพุตหนึ่งคอลัมน์คือคอลัมน์เวลาที่ชื่อdsว่า และคอลัมน์อินพุตหนึ่งคอลัมน์เป็นคอลัมน์ค่าที่ชื่อว่าy คอลัมน์เวลาควรมีรูปแบบข้อมูลวันที่ เวลา หรือวันที่เวลา (ตัวอย่างเช่น YYYY_MM) ชุดข้อมูลที่นี่ตรงตามเงื่อนไขดังกล่าว คอลัมน์ค่าต้องเป็นรูปแบบข้อมูลตัวเลข

สําหรับการพอดีกับแบบจําลอง คุณต้องเปลี่ยนชื่อคอลัมน์เวลาเป็น ds และคอลัมน์ค่าเป็น yและส่งผ่านข้อมูลไปยัง Prophet อ่านเอกสารประกอบ Python API ของ Prophet สําหรับข้อมูลเพิ่มเติม

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

ศาสดาพยากรณ์ทําตามแบบแผนการ Scikit-learn ก่อนอื่น สร้างอินสแตนซ์ใหม่ของ Prophet ตั้งค่าพารามิเตอร์บางอย่าง (ตัวอย่างเช่น)seasonality_mode จากนั้นจึงพอดีกับอินสแตนซ์นั้นกับชุดข้อมูล

• แม้ว่าปัจจัยการบวกคงที่เป็นผลกระทบตามฤดูกาลเริ่มต้นสําหรับศาสดาพยากรณ์ แต่คุณควรใช้ กาล 'คูณ' สําหรับพารามิเตอร์ผลกระทบตามฤดูกาล การวิเคราะห์ในส่วนก่อนหน้านี้แสดงให้เห็นว่าเนื่องจากการเปลี่ยนแปลงของความกว้างตามฤดูกาล ฤดูกาลที่เพิ่มง่ายจะไม่พอดีกับข้อมูลเลย

• ตั้งค่าพารามิเตอร์ weekly_seasonality เป็น ปิด เนื่องจากข้อมูลถูกรวมตามเดือน ด้วยเหตุนี้ ข้อมูลรายสัปดาห์จึงไม่พร้อมใช้งาน

• ใช้ วิธีการของ Markov Chain Monte Carlo (MCMC) เพื่อจับภาพการประมาณความไม่แน่นอนตามฤดูกาล ตามค่าเริ่มต้น ศาสดาพยากรณ์สามารถประมาณความไม่แน่นอนเกี่ยวกับแนวโน้มและเสียงรบกวนในการสังเกต แต่ไม่ใช่สําหรับกาล MCMC ต้องใช้เวลาในการประมวลผลมากขึ้น แต่ช่วยให้อัลกอริทึมสามารถประมาณความไม่แน่นอนเกี่ยวกับฤดูกาลและแนวโน้มและเสียงรบกวนในการสังเกต อ่านเอกสารประกอบช่วงเวลาความไม่แน่นอนของศาสดาพยากรณ์สําหรับข้อมูลเพิ่มเติม

• ปรับแต่งระดับความลับของการตรวจหาจุดเปลี่ยนแปลงอัตโนมัติผ่านพารามิเตอร์ changepoint_prior_scale อัลกอริทึมของ Prophet จะพยายามค้นหาอินสแตนซ์ในข้อมูลที่ trajectories เปลี่ยนแปลงอย่างทันทีทันใด ซึ่งอาจเป็นเรื่องยากในการค้นหาค่าที่ถูกต้อง เพื่อแก้ไขปัญหานี้ คุณสามารถลองค่าที่แตกต่างกัน จากนั้นเลือกแบบจําลองที่มีประสิทธิภาพที่ดีที่สุด อ่านเอกสารประกอบการเปลี่ยนแปลงแนวโน้มศาสดาพยากรณ์สําหรับข้อมูลเพิ่มเติม

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

การตรวจสอบความถูกต้องข้าม

ศาสดาพยากรณ์มีเครื่องมือตรวจสอบข้ามที่มีอยู่ภายใน เครื่องมือนี้สามารถประมาณข้อผิดพลาดการคาดการณ์และค้นหาแบบจําลองที่มีประสิทธิภาพที่ดีที่สุด

เทคนิคการตรวจสอบความถูกต้องข้ามสามารถตรวจสอบประสิทธิภาพของแบบจําลองได้ เทคนิคนี้จะฝึกแบบจําลองในชุดย่อยของชุดข้อมูลและเรียกใช้การทดสอบในชุดย่อยที่ยังไม่มองเห็นก่อนหน้านี้ของชุดข้อมูล เทคนิคนี้สามารถตรวจสอบว่าแบบจําลองทางสถิติกําหนดทั่วไปไปยังชุดข้อมูลอิสระได้ดีเพียงใด

สําหรับการตรวจสอบข้าม ให้จองตัวอย่างเฉพาะของชุดข้อมูลซึ่งไม่ใช่ส่วนหนึ่งของชุดข้อมูลการฝึกอบรม จากนั้นทดสอบแบบจําลองที่ได้รับการฝึกเกี่ยวกับตัวอย่างนั้นก่อนที่จะปรับใช้ อย่างไรก็ตาม วิธีการนี้ใช้ไม่ได้กับข้อมูลอนุกรมเวลา เนื่องจากถ้าแบบจําลองได้เห็นข้อมูลจากเดือนมกราคม 2005 และมีนาคม 2005 และคุณพยายามคาดการณ์สําหรับเดือนกุมภาพันธ์ 2005 แบบจําลองสามารถโกงได้อย่างมากเนื่องจากอาจเห็นตําแหน่งที่แนวโน้มข้อมูลมีลูกค้าเป้าหมาย ในแอปพลิเคชันจริงจุดมุ่งหมายคือการพยากรณ์สําหรับ อนาคตในฐานะภูมิภาคที่ยังไม่เปิดเผย

ในการจัดการสิ่งนี้และทําให้การทดสอบเชื่อถือได้ให้แยกชุดข้อมูลตามวันที่ ใช้ชุดข้อมูลจนถึงวันที่ที่กําหนด (ตัวอย่างเช่น ข้อมูล 11 ปีแรก) สําหรับการฝึก และจากนั้นใช้ข้อมูลที่เหลือที่ยังไม่มองเห็นสําหรับการคาดการณ์

ในสถานการณ์นี้ เริ่มต้นด้วยข้อมูลการฝึก 11 ปี จากนั้นทําการคาดการณ์รายเดือนโดยใช้ขอบเขตหนึ่งปี โดยเฉพาะข้อมูลการฝึกประกอบด้วยทุกอย่างตั้งแต่ปี 2003 ถึงปี 2013 จากนั้น การเรียกใช้ครั้งแรกจะจัดการการคาดการณ์สําหรับเดือนมกราคม 2014 ถึงมกราคม 2015 การเรียกใช้ถัดไปจะจัดการการคาดการณ์สําหรับเดือนกุมภาพันธ์ 2014 ถึงเดือนกุมภาพันธ์ 2015 และอื่น ๆ

ทําซ้ํากระบวนการนี้สําหรับแต่ละแบบจําลองที่ได้รับการฝึกเพื่อดูว่าแบบจําลองใดทํางานได้ดีที่สุด จากนั้นเปรียบเทียบการคาดการณ์เหล่านี้กับค่าในโลกแห่งความเป็นจริงเพื่อสร้างคุณภาพการคาดการณ์ของแบบจําลองที่ดีที่สุด

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

ล็อกแบบจําลองด้วย MLflow

บันทึกแบบจําลองเพื่อติดตามพารามิเตอร์และบันทึกแบบจําลองเพื่อใช้งานในภายหลัง ข้อมูลแบบจําลองที่เกี่ยวข้องทั้งหมดจะถูกบันทึกไว้ในพื้นที่ทํางานภายใต้ชื่อการทดลอง แบบจําลอง พารามิเตอร์ และเมตริก พร้อมกับรายการบันทึกอัตโนมัติของ MLflow จะถูกบันทึกไว้ในการเรียกใช้ MLflow หนึ่งครั้ง

# Setup MLflow
from mlflow.models.signature import infer_signature

ดําเนินการทดลอง

การทดลองการเรียนรู้ของเครื่องทําหน้าที่เป็นหน่วยหลักขององค์กรและการควบคุมสําหรับการเรียกใช้การเรียนรู้ของเครื่องที่เกี่ยวข้องทั้งหมด การเรียกใช้สอดคล้องกับการดําเนินการเดียวของรหัสแบบจําลอง การติดตามการทดลองการเรียนรู้ของเครื่องหมายถึงการจัดการการทดลองและส่วนประกอบที่แตกต่างกันทั้งหมด ซึ่งรวมถึงพารามิเตอร์ เมตริก แบบจําลอง และสิ่งประดิษฐ์อื่น ๆ และช่วยจัดระเบียบคอมโพเนนต์ที่จําเป็นของการทดลองการเรียนรู้ของเครื่องที่เฉพาะเจาะจง การติดตามการทดสอบการเรียนรู้ของเครื่องยังช่วยให้สามารถทําซ้ําผลลัพธ์ที่ผ่านมาได้ง่ายด้วยการทดสอบที่บันทึกไว้ เรียนรู้เพิ่มเติมเกี่ยวกับการทดลองการเรียนรู้ของเครื่องใน Microsoft Fabric เมื่อคุณกําหนดขั้นตอนที่คุณต้องการรวม (ตัวอย่างเช่น การปรับให้เหมาะสมและการประเมินแบบจําลองศาสดาพยากรณ์ในสมุดบันทึกนี้) คุณสามารถเรียกใช้การทดลองได้

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)

แสดงภาพแบบจําลองด้วย Prophet

ศาสดาพยากรณ์มีฟังก์ชันการแสดงภาพที่มีอยู่ภายในซึ่งสามารถแสดงผลลัพธ์แบบจําลองที่เหมาะสม

จุดสีดําแสดงถึงจุดข้อมูลที่ใช้ในการฝึกแบบจําลอง เส้นสีน้ําเงินคือการคาดการณ์ และพื้นที่สีน้ําเงินอ่อนแสดงช่วงเวลาที่ไม่แน่นอน คุณได้สร้างแบบจําลองสามแบบที่มีค่าแตกต่างกันchangepoint_prior_scale การคาดการณ์ของแบบจําลองทั้งสามนี้จะแสดงในผลลัพธ์ของบล็อกรหัสนี้

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

ค่าที่น้อยที่สุด changepoint_prior_scale ในกราฟแรกทําให้เกิดการเปลี่ยนแปลงของแนวโน้มที่น้อยไปมาก ค่ามากที่สุด changepoint_prior_scale ในกราฟที่สามอาจส่งผลให้เกิดความยุ่งยากมากเกินไป ดังนั้นกราฟที่สองจึงดูเหมือนจะเป็นตัวเลือกที่เหมาะสมที่สุด นี่หมายความว่าแบบจําลองที่สองเหมาะสมที่สุด

แสดงภาพแนวโน้มและกาลด้วยศาสดาพยากรณ์

ศาสดาพยากรณ์ยังสามารถแสดงภาพแนวโน้มพื้นฐานและฤดูกาลได้อย่างง่ายดาย แสดงภาพของแบบจําลองที่สองจะแสดงในผลลัพธ์ของบล็อกรหัสนี้

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

ในกราฟเหล่านี้ การแรเงาสีน้ําเงินอ่อนสะท้อนถึงความไม่แน่นอน กราฟด้านบนแสดงแนวโน้มการสั่นสะเทือนในระยะยาวที่แข็งแกร่ง ปริมาณยอดขายเพิ่มขึ้นและลดลงในช่วงหลายปีที่ผ่านมา กราฟด้านล่างแสดงให้เห็นว่ายอดขายมีแนวโน้มที่จะสูงสุดในเดือนกุมภาพันธ์และกันยายน ถึงค่าสูงสุดสําหรับปีในเดือนเหล่านั้น ไม่นานหลังจากเดือนเหล่านั้นในเดือนมีนาคมและตุลาคม พวกเขาจะตกอยู่ในค่าต่ําสุดของปี

ประเมินประสิทธิภาพของแบบจําลองโดยใช้เมตริกต่าง ๆ ตัวอย่างเช่น:

• ข้อผิดพลาดที่เป็นรูปสี่เหลี่ยมจัตุรัส (MSE)
• ข้อผิดพลาดรากที่สอง (RMSE)
• ข้อผิดพลาดแบบสัมบูรณ์ (MAE)
• ข้อผิดพลาดของเปอร์เซ็นต์แบบสัมบูรณ์ (MAPE)
• ข้อผิดพลาดเปอร์เซ็นต์สัมบูรณ์มัธยฐาน (MDAPE)
• ข้อผิดพลาดเปอร์เซ็นต์แบบสัมบูรณ์แบบสัมบูรณ์ของค่าเฉลี่ยสมมาตร (SMAPE)

ประเมินความครอบคลุมโดยใช้ yhat_lower และ yhat_upper การประเมิน โปรดสังเกตขอบเขตที่แตกต่างกันซึ่งคุณคาดการณ์ไว้หนึ่งปีในอนาคต 12 ครั้ง

display(df_metrics[BEST_MODEL_INDEX])

ด้วยเมตริก MAPE สําหรับแบบจําลองการคาดการณ์นี้ การคาดการณ์ที่ขยายหนึ่งเดือนในอนาคตมักเกี่ยวข้องกับข้อผิดพลาดประมาณ 8% อย่างไรก็ตาม สําหรับการคาดการณ์หนึ่งปีในอนาคต ข้อผิดพลาดจะเพิ่มขึ้นประมาณ 10%

ขั้นตอนที่ 5: ให้คะแนนแบบจําลองและบันทึกผลลัพธ์การคาดการณ์

ตอนนี้ให้คะแนนแบบจําลองและบันทึกผลลัพธ์การคาดการณ์

ทําการคาดการณ์ด้วยการทํานายหม้อแปลง

ในตอนนี้ คุณสามารถโหลดแบบจําลองและใช้เพื่อทําการคาดการณ์ได้แล้ว ผู้ใช้สามารถใช้งานแบบจําลองการเรียนรู้ของเครื่องด้วย PREDICT ซึ่งเป็นฟังก์ชัน Microsoft Fabric ที่ปรับขนาดได้ที่สนับสนุนการให้คะแนนแบบกลุ่มในกลไกการคํานวณใดก็ตาม เรียนรู้เพิ่มเติมเกี่ยวกับ PREDICTและวิธีการใช้งานภายใน Microsoft Fabric ที่ ทรัพยากรนี้

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.")

เนื้อหาที่เกี่ยวข้อง

• แบบจําลองการเรียนรู้ของเครื่องใน Microsoft Fabric
• ฝึกแบบจําลองการเรียนรู้ของเครื่อง
• การทดลองการเรียนรู้ของเครื่องใน Microsoft Fabric