Pandas & NumPy Academy · บทเรียน

การวิเคราะห์กรวย

ติดตามจำนวนผู้ใช้ที่ไปถึงแต่ละขั้นของกรวยหลายขั้น และคำนวณอัตราการเปลี่ยนผ่านระหว่างขั้นที่ต่อเนื่องกัน

การวิเคราะห์กรวย เป็นบทเรียน Pandas & NumPy Academy ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน Pandas & NumPy Academy และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส Pandas & NumPy Academy มีบทเรียนทั้งหมด 4 บทเรียน

กรวยการเปลี่ยนผู้ใช้คืออะไร

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

import pandas as pd

FUNNEL_STEPS = [
    'homepage',
    'product_page',
    'add_to_cart',
    'checkout',
    'purchase'
]

df = pd.read_csv('clickstream.csv', parse_dates=['timestamp'])
print(df['event_type'].value_counts())

การนับผู้ใช้ที่ไม่ซ้ำกันในแต่ละขั้น

สำหรับแต่ละขั้นของกรวย ให้นับจำนวนผู้ใช้ที่ไม่ซ้ำกันซึ่งทำเหตุการณ์นั้นอย่างน้อยหนึ่งครั้ง ใช้ df[df['event_type'] == step]['user_id'].nunique() ภายในลูป แล้วรวบรวมผลลัพธ์ไว้ในพจนานุกรม การแปลงผลลัพธ์เป็น Series จะทำให้การคำนวณเปอร์เซ็นต์ในขั้นถัดไปทำได้ง่ายด้วยการหารเพียงครั้งเดียว

step_counts = {}
for step in FUNNEL_STEPS:
    users = df[df['event_type'] == step]['user_id'].nunique()
    step_counts[step] = users

funnel = pd.Series(step_counts, name='users')
print(funnel)

การคำนวณอัตราการเปลี่ยนระหว่างขั้น

อัตราการเปลี่ยนระหว่างขั้นแสดงสัดส่วนของผู้ใช้ที่ทำขั้น N สำเร็จและทำขั้น N+1 สำเร็จต่อไป คำนวณด้วย funnel.shift(1) ซึ่งให้จำนวนของขั้นก่อนหน้า แล้วนำมาหารดังนี้: funnel / funnel.shift(1) * 100 ขั้นแรกไม่มีขั้นก่อนหน้า ดังนั้นอัตราของขั้นนี้อาจเป็น NaN หรือ 100% ขึ้นอยู่กับวิธีกำหนดค่าฐาน

funnel_df = funnel.to_frame()
funnel_df['prev_users'] = funnel_df['users'].shift(1)
funnel_df['step_conversion_%'] = (funnel_df['users'] / funnel_df['prev_users'] * 100).round(1)
print(funnel_df)

การคำนวณอัตราการเปลี่ยนโดยรวม

อัตราการเปลี่ยนโดยรวมวัดสัดส่วนของผู้ใช้ทั้งหมดที่เข้าสู่กรวยในขั้นที่ 1 แล้วทำขั้นสุดท้ายสำเร็จ นำจำนวนผู้ใช้ในขั้นสุดท้ายหารด้วยจำนวนผู้ใช้ในขั้นแรก อัตราการเปลี่ยนโดยรวมจากหน้าแรกไปจนถึงการซื้อสินค้าที่ 2–5% ถือเป็นค่าปกติสำหรับการค้าปลีกออนไลน์ หากต่ำกว่านี้แสดงว่ามีผู้ใช้หลุดออกจากกรวยเป็นจำนวนมากในจุดใดจุดหนึ่ง

overall_rate = funnel.iloc[-1] / funnel.iloc[0] * 100
print(f'Overall conversion rate: {overall_rate:.1f}%')

funnel_df['overall_conversion_%'] = (funnel_df['users'] / funnel_df['users'].iloc[0] * 100).round(1)
print(funnel_df[['users', 'overall_conversion_%']])

กรวยตามลำดับ: การกำหนดให้มีลำดับขั้น

การนับผู้ใช้ที่ไม่ซ้ำกันแบบง่ายจะถือว่าผู้ใช้ที่ข้ามไปยังหน้าชำระเงินโดยไม่เคยเข้าหน้าผลิตภัณฑ์เป็นผู้ใช้ที่เข้าสู่กรวยอย่างถูกต้อง ทำให้อัตราการเปลี่ยนในขั้นต้นสูงเกินจริง หากต้องการบังคับใช้ลำดับ ให้ตรวจสอบว่าผู้ใช้แต่ละคนไปถึงขั้น N หลังจากไปถึงขั้น N-1 แล้วเท่านั้น ซึ่งต้องเปรียบเทียบเวลา โดยผู้ใช้ต้องมีเหตุการณ์ product_page ก่อน เหตุการณ์ add_to_cart

# Get first occurrence of each step per user
first_events = df.groupby(['user_id', 'event_type'])['timestamp'].min().unstack('event_type')

# Enforce ordering: each step must come after the previous
first_events['valid_to_cart'] = first_events['add_to_cart'] > first_events['product_page']
print(first_events[['product_page', 'add_to_cart', 'valid_to_cart']].head())

กรวยตามกลุ่ม: ประเภทอุปกรณ์

ผู้ใช้แต่ละกลุ่มอาจมีอัตราการเปลี่ยนแตกต่างกันมาก ให้คำนวณกรวยแบบเดียวกันแยกสำหรับผู้ใช้เดสก์ท็อปและมือถือโดยใช้ groupby('device_type') หากผู้ใช้มือถือหลุดออกเป็นจำนวนมากในขั้นชำระเงิน หน้าชำระเงินนั้นอาจมีปัญหาด้านการใช้งานบนหน้าจอขนาดเล็ก กรวยที่แบ่งตามกลุ่มช่วยเปิดเผยโอกาสในการปรับปรุงที่ตรงจุด

def funnel_for_group(group_df):
    counts = {}
    for step in FUNNEL_STEPS:
        counts[step] = group_df[group_df['event_type'] == step]['user_id'].nunique()
    return pd.Series(counts)

segmented_funnel = df.groupby('device_type').apply(funnel_for_group)
print(segmented_funnel)

การระบุขั้นที่มีผู้ใช้หลุดออกมากที่สุด

ขั้นที่มีจำนวนผู้ใช้สูญเสียแบบสัมบูรณ์มากที่สุดคือเป้าหมายที่ควรให้ความสำคัญสูงสุดในการปรับปรุง ค้นหาขั้นดังกล่าวโดยคำนวณผลต่างระหว่างจำนวนผู้ใช้ในขั้นที่ต่อเนื่องกันด้วย funnel.diff() ค่าที่ติดลบมากที่สุดจะตรงกับขั้นที่มีผู้ใช้หลุดออกมากที่สุด นำเสนอข้อมูลเชิงลึกนี้ทั้งในรูปแบบตัวเลขและภาพเพื่อให้ผู้มีส่วนได้ส่วนเสียเข้าใจได้ง่าย

dropoffs = funnel.diff().abs()
biggest_drop = dropoffs.idxmax()
biggest_drop_count = dropoffs.max()

print(f'Biggest drop-off: {biggest_drop} ({biggest_drop_count:.0f} users lost)')

เวลาระหว่างขั้นของกรวย

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

for i in range(1, len(FUNNEL_STEPS)):
    prev = FUNNEL_STEPS[i-1]
    curr = FUNNEL_STEPS[i]
    delta = (first_events[curr] - first_events[prev]).dt.total_seconds() / 60
    print(f'{prev} -> {curr}: median {delta.median():.1f} min, 90th pct {delta.quantile(0.9):.1f} min')

แนวโน้มกรวยรายสัปดาห์

ติดตามว่าอัตราการเปลี่ยนดีขึ้นหรือลดลงในแต่ละสัปดาห์ โดยคำนวณกรวยแยกสำหรับแต่ละสัปดาห์ จัดกลุ่มตารางเหตุการณ์แรกตามสัปดาห์โดยใช้ first_events['homepage'].dt.isocalendar().week แล้วคำนวณอัตราการเปลี่ยนโดยรวมของแต่ละสัปดาห์ การลดลงอย่างฉับพลันในสัปดาห์ใดสัปดาห์หนึ่งอาจเกิดขึ้นพร้อมกับการเผยแพร่ผลิตภัณฑ์หรือการเปลี่ยนแปลงด้านการตลาด

df['week'] = df['timestamp'].dt.isocalendar().week

weekly_conv = []
for week, wdf in df.groupby('week'):
    top = wdf[wdf['event_type'] == FUNNEL_STEPS[0]]['user_id'].nunique()
    bot = wdf[wdf['event_type'] == FUNNEL_STEPS[-1]]['user_id'].nunique()
    weekly_conv.append({'week': week, 'conversion_%': bot/top*100 if top else 0})

print(pd.DataFrame(weekly_conv))

การสร้าง DataFrame สรุปกรวย

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

summary = pd.DataFrame({
    'step': FUNNEL_STEPS,
    'users': [step_counts[s] for s in FUNNEL_STEPS]
})
summary['users_lost'] = summary['users'].shift(-1).rsub(summary['users'])
summary['step_conv_%'] = (summary['users'] / summary['users'].shift(1) * 100).round(1)
summary['overall_conv_%'] = (summary['users'] / summary['users'].iloc[0] * 100).round(1)
print(summary)

การแสดงกรวยเป็นกราฟแท่ง

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

import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(8, 5))
ax.barh(summary['step'][::-1], summary['users'][::-1], color='steelblue')
for i, row in summary[::-1].iterrows():
    ax.text(row['users'], i - summary.index[0], f'  {row['step_conv_%']}%', va='center')
ax.set_xlabel('Unique Users')
ax.set_title('Conversion Funnel')
plt.tight_layout()
plt.show()

ตรวจสอบความเข้าใจอย่างรวดเร็ว

ทดสอบความเข้าใจแนวคิดการวิเคราะห์ข้อมูลจากบทเรียนนี้

สรุปบทเรียน

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

คำถามที่พบบ่อย

บทเรียน “การวิเคราะห์กรวย” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “การวิเคราะห์กรวย” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส Pandas & NumPy Academy ให้อัปเกรดเป็น CoddyKit PRO คอร์ส Pandas & NumPy Academy มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “การวิเคราะห์กรวย”

ติดตามจำนวนผู้ใช้ที่ไปถึงแต่ละขั้นของกรวยหลายขั้น และคำนวณอัตราการเปลี่ยนผ่านระหว่างขั้นที่ต่อเนื่องกัน คุณปฏิบัติ Pandas & NumPy Academy ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน Pandas & NumPy Academy หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน Pandas & NumPy Academy บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “การวิเคราะห์กรวย” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน Pandas & NumPy Academy นี้ได้ไหม

ได้ บทเรียน Pandas & NumPy Academy ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ Pandas & NumPy Academy