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

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

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

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

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

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

    สกรีนช็อตที่แสดงการเลือก Fabric บนเมนูตัวสลับประสบการณ์

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

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

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

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

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

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

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

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

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

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

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

  1. ใช้ความสามารถในการติดตั้งแบบอินไลน์ (ตัวอย่างเช่น %pip, %conda และอื่นๆ) เพื่อ get started กับไลบรารีใหม่ได้อย่างรวดเร็ว วิธีนี้จะติดตั้งไลบรารีแบบกําหนดเองเฉพาะในสมุดบันทึกปัจจุบัน ไม่ใช่ในพื้นที่ทํางาน
# Use pip to install libraries
%pip install <library name>

# Use conda to install libraries
%conda install <library name>
  1. อีกวิธีหนึ่งคือ สร้างสภาพแวดล้อม Fabric ติดตั้งไลบรารีจากแหล่งข้อมูลสาธารณะ หรืออัปโหลดไลบรารีแบบกําหนดเองไปยังสภาพแวดล้อม ผู้ดูแลระบบพื้นที่ทํางานของคุณสามารถแนบสภาพแวดล้อมเป็นค่าเริ่มต้นสําหรับพื้นที่ทํางานได้ ไลบรารีทั้งหมดในสภาพแวดล้อมจะพร้อมใช้งานในสมุดบันทึกและข้อกําหนดงาน Spark ในพื้นที่ทํางาน สําหรับข้อมูลเพิ่มเติมเกี่ยวกับสภาพแวดล้อม โปรดดู สร้าง กําหนดค่า และใช้สภาพแวดล้อมใน Microsoft Fabric

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

# Use pip to install Prophet
%pip install prophet

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

ชุดข้อมูล

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

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

borough ย่าน building_class_category tax_class block ที่ดิน อีสต์เมน building_class_at_present ที่อยู่ 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
แมน ฮัต ตัน เมืองอัลฟ่าเบต 07 เช่า - วอล์คอัพ อพาร์ตเมนต์ 0.0 384.0 17.0 C4 225 ถนนตะวันออก 2 10009.0 10.0 0.0 10.0 2145.0 6670.0 1900.0 2.0 C4 275000.0 2007-06-19
แมน ฮัต ตัน เมืองอัลฟ่าเบต 07 เช่า - วอล์คอัพ อพาร์ตเมนต์ 2.0 405.0 12.0 C7 ถนน 508 สายตะวันออก 12 10009.0 28.0 2.0 30.0 3872.0 15428.0 1930.0 2.0 C7 7794005.0 2007-05-21

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

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

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

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

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

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

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

เคล็ดลับ

ด้วยการใช้พารามิเตอร์ที่แสดงในเซลล์โค้ดนี้ คุณสามารถใช้สมุดบันทึกนี้กับชุดข้อมูลต่างๆ ได้อย่างง่ายดาย

URL = "https://synapseaisolutionsa.z13.web.core.windows.net/data/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

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

# Set up the MLflow experiment
import mlflow

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

หมายเหตุ

หากต้องการปิดใช้งาน Microsoft Fabric การบันทึกอัตโนมัติในเซสชันสมุดบันทึก ให้เรียก mlflow.autolog() และตั้งค่า disable=True

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

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" กรองชุดข้อมูลเพื่อรวมเฉพาะอาคารที่อยู่อาศัย To do นี้ ให้รวมคอลัมน์ building_class_at_time_of_sale หรือ building_class_at_present รวม building_class_at_time_of_sale เฉพาะข้อมูลเท่านั้น

  • ชุดข้อมูลประกอบด้วยอินสแตนซ์ที่ total_units ค่าเท่ากับ 0 หรือ gross_square_feet ค่าเท่ากับ 0 ลบอินสแตนซ์ total_units ทั้งหมดที่ หรือ gross_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_units, และ gross_square_feetsales_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 จึงเล็กลง การเปลี่ยนแปลงนี้แสดงให้เห็นว่าคุณสามารถใช้ DataFrames ของแพนด้าได้แล้ว

รหัสนี้จะแปลงชุดข้อมูลจาก 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: การฝึกอบรมและการติดตามแบบจําลอง

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

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

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

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

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

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

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

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

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

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

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

การทดลอง machine learning ทําหน้าที่เป็นหน่วยหลักขององค์กรและการควบคุมสําหรับการเรียกใช้ machine learning ที่เกี่ยวข้องทั้งหมด การเรียกใช้สอดคล้องกับการดําเนินการเดียวของรหัสแบบจําลอง การติดตามการทดลอง Machine learning หมายถึงการจัดการการทดลองต่างๆ ทั้งหมดและส่วนประกอบต่างๆ การจัดการนี้รวมถึงพารามิเตอร์ เมตริก แบบจําลอง และสิ่ง artifacts อื่นๆ ช่วยจัดระเบียบส่วนประกอบที่จําเป็นของการทดลอง machine learning เฉพาะ การติดตามการทดลอง Machine learning ยังช่วยให้ทําซ้ําผลลัพธ์ที่ผ่านมาได้อย่างง่ายดายด้วยการทดสอบที่บันทึกไว้ สําหรับข้อมูลเพิ่มเติม โปรดดู machine learning การทดสอบใน 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

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_loweryhat_upper ประมาณการ โปรดสังเกตขอบเขตที่แตกต่างกันซึ่งคุณคาดการณ์ไว้หนึ่งปีในอนาคต 12 ครั้ง

display(df_metrics[BEST_MODEL_INDEX])

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

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

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

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

โหลดแบบจําลองและใช้เพื่อทําการคาดการณ์ เมื่อต้องการดําเนินการแบบจําลอง machine learning ให้ใช้ 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.")

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

  • Last updated on