Category: Data analytics

  • 4 ขั้นตอนการใช้งาน Claude Code เพื่อให้ได้ Code ที่ตอบโจทย์

    4 ขั้นตอนการใช้งาน Claude Code เพื่อให้ได้ Code ที่ตอบโจทย์

    Claude Code เป็น AI coding assistant ที่กำลังได้รับความนิยม ด้วยความสามารถในการประมวลผลคำสั่ง และความสามารถในการทำงานกับไฟล์บนคอมพิวเตอร์ได้โดยตรง ช่วยลดเวลาในการ copy-paste code ไปมาระหว่าง Claude และไฟล์

    แม้ Claude Code จะสามารถเขียน code ได้ดี แต่ก็ไม่ได้หมายความว่า เราจะได้ code ที่ตอบโจทย์ทุกครั้ง

    เช่น เราสั่งให้ Claude Code สร้างเว็บ chatbot ทั้งหน้าตา การทำงาน และการเก็บข้อมูลอาจไม่ได้เป็นไปตามที่เราคาดหวัง ทำให้เราต้องเวลาเพิ่มขึ้นเพื่อสั่งให้ Claude แก้ไขงาน

    ในบทความนี้ ผมจะมาแนะนำ 4 ขั้นตอนในการทำงานกับ Claude Code เพื่อให้ได้ code ที่ตอบโจทย์

    ถ้าทุกคนพร้อมแล้ว ไปเริ่มกันเลย



    🤨 ทำไมต้อง 4 ขั้นตอน?

    4 ขั้นตอนในการทำงานกับ Claude Code ได้แก่:

    1. Explore
    2. Plan
    3. Code
    4. Commit

    สังเกตว่า ทั้ง 4 ขั้นเหมือนกับการเขียน code ของมนุษย์ ถ้าเราสั่งให้ developer สร้างเว็บไซต์ สิ่งที่ developer จะทำ คือ:

    1. ทำความเข้าใจความต้องการและข้อมูลที่มี (explore)
    2. วางแผนและออกแบบการเขียน code (plan)
    3. ลงมือเขียน (code)
    4. ส่งงานให้ตรวจ (commit)

    จะเห็นว่า แต่ละขั้นส่งเสริมซึ่งกันและกัน ถ้าไม่ทำความเข้าใจงาน ก็วางแผนไม่ได้ และถ้าวางแผนไม่ได้ ก็เขียน code ได้ไม่ดี และทำให้งานที่ส่งไม่มีคุณภาพ

    การทำงานกับ Claude ก็เช่นกัน ถ้าเราสั่งให้เขียน code โดยไม่ทำความเข้าใจงานและวางแผนก่อน code ที่ออกมาก็มีโอกาสที่จะผิดพลาดสูง

    ดังนั้น เพื่อให้ได้ code ที่ตอบโจทย์ เราจะต้องทำงานใน 4 ขั้นตอน:

    1. Explore
    2. Plan
    3. Code
    4. Commit

    🧑‍💻 วิธีใช้ Claude Code ที่ถูกต้อง ใน 4 ขั้นตอน

    .

    🔍 Step 1. Explore

    ในขั้นแรก เราจะต้องบอกให้ Claude ทำความเข้าใจงานก่อน โดย:

    1. เปิด plan mode โดยกด shift + tab จนกว่าจะถึง plan mode หรือพิมพ์คำสั่ง /plan
    2. สั่งให้ Claude อ่านไฟล์ใน folder ที่เรากำหนด โดยใน folder นี้สามารถมีได้ทั้งไฟล์ความต้องการ และ code ที่เราเคยเขียนไว้

    ตัวอย่าง:

    อ่านไฟล์ requirements.md
    เพื่อเข้าใจเป้าหมาย user persona
    ปัญหาที่ต้องการแก้ด้วยเว็บไซต์
    และการแบ่ง module ในการพัฒนา

    .

    🗺️ Step 2. Plan

    ในขั้นที่ 2 เราจะสั่งให้ Claude วางแผนงาน

    ตัวอย่าง:

    วางแผนการออกแบบ module 1 ของเว็บไซต์
    เริ่มตั้งแต่ user เข้าสู่ระบบไปจนถึง ...

    Tips:

    ถ้าต้องการให้ Claude คิดเยอะ ๆ เราใช้คำสั่ง think เข้ามาช่วยได้:

    KeywordLevel of Thinking
    thinkคิดระดับพื้นฐาน
    think moreคิดเพิ่มขึ้น
    think a lotคิดให้ครอบคลุม
    think longerคิดให้นานขึ้น
    ultrathinkคิดให้มากที่สุด

    ตัวอย่าง:

    ultrathink วางแผนการออกแบบ module 1 ของเว็บไซต์

    หมายถึงให้คิดเกี่ยวกับแผนการทำงาน module 1 ให้มากที่สุดเท่าที่จะทำได้

    Note: ยิ่งคิดเยอะก็จะยิ่งใช้ token เยอะ และทำให้เราติด limit ในการใช้งานเร็วขึ้น

    เมื่อ Claude ส่งแผนกลับมาแล้ว เราสามารถแก้ไขแผนเพื่อช่วยกำหนดทิศทางก่อนที่จะเขียน code ได้ ซึ่งเราทำได้ 2 วิธี:

    1. กด ctrl + G เพื่อแก้ไขแผนเอง
    2. บอก Claude ว่าอะไรที่ยังไม่ใช่ เพื่อให้ Claude แก้แผนให้

    ตัวอย่าง:

    เพิ่มการ unit test สำหรับแต่ละ function

    .

    💻 Step 3. Code

    เมื่อพอใจกับแผนแล้ว เราจะสั่งให้ Claude เขียน code ตามแผนที่วางไว้:

    1. ออกจาก plan mode ด้วยคำสั่ง /plan หรือกด shift + tab
    2. สั่งให้เขียน code ตามแผน

    ตัวอย่าง:

    เขียน code ตามแผนด้านบน
    เขียนแล้ว ให้ทดสอบและแก้ไขจุดผิดพลาดที่เจอด้วย
    ก่อนจะส่งงานกลับมา

    .

    🚀 Step 4. Commit

    ในขั้นสุดท้าย เราจะสั่งให้ Claude ช่วย commit code ให้

    ตัวอย่าง:

    Commit code
    พร้อม commit message สั้น ๆ
    เพื่อรอ review

    💪 Summary

    การทำงานกับ Claude Code ที่ดีไม่ใช่การสั่งให้เขียน code เลย แต่จะต้อง:

    1. Explore: ทำความเข้าใจเนื้องานที่ต้องทำ
    2. Plan: กำหนดทิศทางและออกแบบการทำงาน
    3. Code: ลงมือทำ
    4. Commit: ส่งงานรอรีวิว

    เมื่อทำงานกับ Claude Code ใน 4 ขั้นตอนนี้แล้ว เราก็จะได้ code ที่ตอบโจทย์มากขึ้น 👍


    ⏭️ Next

    หลังอ่านบทความนี้แล้ว ลองใช้งาน Claude Code กันดูครับ:


    📃 References

    Fediverse Reactions
  • 5 วิธีจัดการ Context ใน Claude Code เพื่อให้เขียน Code ได้ดีขึ้น

    5 วิธีจัดการ Context ใน Claude Code เพื่อให้เขียน Code ได้ดีขึ้น

    Claude Code เป็น AI ช่วยเขียน code ที่ช่วยเราวางแผน เขียน และแก้ไข code บนคอมพิวเตอร์ได้ผ่านคำสั่งภาษาธรรมชาติ (natural language)

    หนึ่งในสิ่งที่ทำให้ Claude Code ทำงานได้อย่างมีประสิทธิภาพ คือ context

    ถ้าไม่มี context, Claude จะขาดบริบทในการทำงาน และไม่สามารถเขียน code ได้อย่างมีประสิทธิภาพได้

    ในบทความนี้ เราจะมาทำความรู้จักกับ context และวิธีใช้งาน context ใน Claude Code อย่างถูกวิธีกัน

    บทความนี้แบ่งเป็น 2 ส่วน:

    1. ความหมายของ context
    2. วิธีจัดการ context ที่ถูกต้อง

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    🤨 Context ใน Claude Code คืออะไร? และสำคัญยังไง?

    Context คือ ความจำในการทำงานของ Claude (working memory)

    Context เก็บประวัติการพูดคุยระหว่างเรากับ Claude รวมถึงการทำงานของ Claude เช่น การอ่านไฟล์และการแก้ไขไฟล์ ซึ่งช่วยให้ Claude มีข้อมูลบริบทในการทำงาน

    เมื่อ context เต็ม Claude จะลืมการพูดคุยช่วงต้น และมีโอกาสทำงานผิดพลาดมากขึ้น

    เช่น ตอนต้น session เราบอกให้ Claude เขียน comment กำกับ code ทุกครั้ง พอ context เต็ม Claude จะลืมคำสั่งนี้ และไม่ comment code ตามที่เราต้องการ

    ดังนั้น เราควรจะจัดการ context ให้ดี เพื่อให้ Claude ทำงานได้อย่างมีประสิทธิภาพมากที่สุด


    👍 วิธีจัดการ Context ที่ถูกต้อง

    5 วิธีในการจัดการ context ไม่ให้เต็มเร็ว:

    1. เขียน prompt ให้เจาะจง
    2. ใช้ CLAUDE.md
    3. ปิดใช้งาน skills and MCPs
    4. ใช้ subagent
    5. ลบหรือสรุปข้อมูล

    .

    ✏️ วิธีที่ 1. เขียน Prompt ให้เจาะจง

    เขียน prompt ให้ชัดเจนและเจาะจง เพื่อที่ Claude จะไม่ต้องคิดทบทวนคำสั่งหลายรอบ

    ❌ ตัวอย่าง prompt ที่เปลือง context:

    แก้ code ให้หน่อย

    เพราะ Claude จะต้องคิดก่อนลงมือทำ:

    • มองหาจุดไหนที่ต้องแก้
    • คิดว่าแก้เพื่ออะไร
    • คิดว่าแก้ยังไง
    • ลงมือแก้

    ทำให้เปลือง context โดยไม่จำเป็น

    ✅ ตัวอย่าง prompt ที่ประหยัด context:

    แก้ calculate_sum() ในไฟล์ @calculator.py
    เพื่อ handle data type ที่ไม่ใช่ int หรือ float

    เพราะ Claude สามารถคิดและลงมือแก้ได้เลย โดยตีกรอบบริบทว่าอะไรที่ต้องแก้บ้าง

    .

    📑 วิธีที่ 2. ใช้ CLAUDE.md

    ใส่บริบทและสิ่งที่ Claude ควรรู้ไว้ใน CLAUDE.md ซึ่งเป็นไฟล์กำกับการทำงานของ Claude เพื่อที่ Claude จะได้เข้าใจบริบทในการทำงานได้โดยไม่ต้องอ่าน code ทั้งหมดใหม่ทุกครั้ง

    ไม่มี CLAUDE.mdมี CLAUDE.md
    อ่าน code ทั้งหมดเพื่อเข้าใจบริบทอ่านแค่ CLAUDE.md

    2 วิธีในการสร้าง CLAUDE.md:

    1. สั่งให้ Claude สร้างให้ ด้วยคำสั่ง /init (แนะนำ)
    2. สร้างเองใน text editor

    ตัวอย่าง CLAUDE.md:

    # Project: My To-Do App
    ## What this is
    A simple to-do list app.
    Frontend only, no backend yet.
    Built with HTML, CSS, and vanilla JavaScript.
    ## Do
    - Keep the code in plain JavaScript
    - Explain any code changes in plain English before making them
    - Always test in the browser before marking tasks as complete
    ## Don't
    - Don't use React, Vue, or any framework
    - Don't rewrite the whole file for a small fix
    - Don't delete comments that explain "why", only "what"

    .

    ⛏️ วิธีที่ 3. ปิดใช้งาน Skill และ MCP

    ปิด skill และ MCP ที่ไม่ใช้งาน

    Claude จะได้รับข้อมูล skill และ MCP ที่เปิดใช้งานทุกครั้ง ไม่ว่า skill หรือ MCP เหล่านี้ถูกใช้งานหรือไม่ก็ตาม

    ดังนั้น เมื่อเราไม่ปิด skill และ MCP ที่เราไม่ใช้แล้ว เราจะเสีย context ไปโดยไม่จำเป็น

    คำสั่งสำหรับปิด skill และ MCP:

    • /skills เพื่อจัดการ Skill
    • /mcp เพื่อจัดการ MCP

    .

    🕵️‍♀️ วิธีที่ 4. ใช้ Subagent

    ใช้งาน subagent หรือ AI agent ที่จะทำงานเฉพาะอย่าง

    Subagent มี context ที่แยกต่างหากจาก main agent ทำให้การทำงานของ subagent ไม่นำมาคิดเป็น context ของ main agent

    วิธีใช้ subagent:

    1. ใช้คำสั่ง /agents เพื่อจัดการ subagent (เช่น สร้างหรือเปิด-ปิดการใช้งาน)
    2. เรียกใช้ subagent ด้วยคำสั่ง @ ตามด้วยชื่อ subagent (เช่น @code-reviewer).

    .

    💻 วิธีที่ 5. ลบหรือสรุปข้อมูล

    ลบหรือสรุปข้อมูล เพื่อเพิ่มพื้นที่ใน context

    3 คำสั่งสำหรับลบและสรุปข้อมูล:

    1. /context: ดูสิ่งที่เก็บไว้ใน context
    2. /clear: ลบข้อมูลใน context
    3. /compact: สรุปข้อมูลใน context

    เมื่อไรควรลบและเมื่อไรควรสรุปข้อมูล?

    • ลบเมื่อ context เต็ม และไม่ต้องการทำงานต่อจากเดิม (เช่น พัฒนา feature ใหม่)
    • สรุปเมื่อ context เต็ม แต่ต้องทำงานต่อจากเดิม (เช่น ปรับปรุง feature เดิม)

    Note: ข้อเสียของการสรุป คือ Claude อาจจะลืมรายละเอียดเล็ก ๆ น้อย ๆ ไปได้


    💪 บทสรุป

    Context เก็บข้อมูลเพื่อให้ Claude เข้าใจบริบทและสามารถทำงานได้อย่างมีประสิทธิภาพ

    5 วิธีในการจัดการ context ไม่ให้เต็ม:

    1. ใช้ prompt ที่มีความเจาะจง
    2. เก็บสิ่งที่ Claude ควรรู้ไว้ใน CLAUDE.md
    3. ปิด skill และ MCP ที่ไม่ใช้งาน
    4. ใช้ subagent ทำงานย่อย
    5. ลบหรือสรุปข้อมูลที่ใน context

    ⏭️ Next

    อ่านบทความจบแล้ว อย่าลืมลองใช้ Claude Code กันนะครับ:

    1. วิธีติดตั้ง Claude Code
    2. คำสั่งที่ควรรู้ในการทำงานกับ Claude Code
    3. วิธีใช้ local model กับ Claude Code

    📃 อ้างอิง

  • 30+ คำสั่ง Claude Code ที่ควรรู้ พร้อมวิธีใช้งาน

    30+ คำสั่ง Claude Code ที่ควรรู้ พร้อมวิธีใช้งาน

    Updated: 07 Aug 2026

    .

    Claude Code เป็น AI coding assistant ที่เราใช้ช่วยเขียน code ลงบนคอมพิวเตอร์ได้โดยตรง

    แม้ว่า Claude Code จะรองรับการทำงานกับภาษาธรรมชาติ (natural language) แต่เราสามารถสั่งงาน Claude ผ่าน command line หรือคำสั่งลัดใน Terminal ได้ด้วยเช่นกัน

    ในบทความนี้ ผมจะพาทุกคนไปดู 30+ คำสั่งที่ทุกคควรรู้ในการใช้งาน Claude Code ได้อย่างมืออาชีพกัน

    ทั้ง 30+ คำสั่งแบ่งได้เป็น 3 กลุ่ม:

    1. Basic: คำสั่งพื้นฐานในการทำงานกับ Claude (12 คำสั่ง)
    2. Intermediate: คำสั่งที่ช่วยให้ Claude ตอบโจทย์เรามากขึ้น (12 คำสั่ง)
    3. Advanced: คำสั่งที่ทำให้ Claude ทำงานโดยอัตโนมัติ (12 คำสั่ง)

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    😎 Claude Code Command Cheat Sheet

    คำสั่งใช้เพื่อ
    claudeเริ่มใช้งาน Claude Code และสร้าง session ใหม่
    ! <command>รัน shell command ระหว่างใช้งาน Claude Code
    @<file>ชี้ไฟล์ให้ Claude Code
    /modelเลือก model ที่ต้องการใช้งาน
    /exitออกจาก session
    /planวางแผนการทำงานก่อนเริ่มเขียนหรือแก้ไข code
    /initสร้างไฟล์ CLAUDE.md สำหรับกำหนดบริบทและแนวทางการทำงาน
    /memoryเปิด CLAUDE.md เพื่อดูหรือแก้ไข
    /btwคุยกับ Claude ระหว่างที่ Claude กำลังทำงาน
    /diffดูการเปลี่ยนแปลงของ code
    /reviewตรวจสอบ code และแนะนำการแก้ไข
    /helpดูคำสั่งและวิธีใช้งาน Claude Code
    claude -cกลับไปใช้งาน session ล่าสุด
    /resumeเลือก session ที่ต้องการกลับไปใช้งานต่อ
    /renameเปลี่ยนชื่อ session
    /contextดู context ที่ถูกใช้ไปใน session
    /compactสรุป context เพื่อเพิ่มพื้นที่สำหรับการทำงานต่อ
    /clearลบข้อมูลใน context ของ session ปัจจุบัน
    /skillsดูและจัดการ skills ที่ Claude Code ใช้งานได้
    /mcpดูและจัดการ MCP ที่ Claude Code ใช้งานได้
    /agentsดูและจัดการ subagents
    /pluginดูและจัดการ plugins ของ Claude Code
    /usageดูจำนวนข้อความคงเหลือที่ยังใช้ได้
    /costดูค่าใช้จ่ายจากการใช้งาน Claude Code
    /goalกำหนดเป้าหมายให้ Claude Code ทำงานต่อเนื่องจนสำเร็จ
    /batchแบ่งงานขนาดใหญ่เป็นงานย่อยและทำงานแบบขนาน
    /scheduleตั้งเวลาให้ Claude Code ทำงานตามกำหนด
    /loopให้ Claude Code ทำงานซ้ำตามช่วงเวลาที่กำหนด
    /backgroundย้ายงานไปทำงานเบื้องหลัง เพื่อใช้ Terminal ต่อได้
    /tasksดูรายการงานที่กำลังทำงานอยู่เบื้องหลัง
    /doctorตรวจสอบการตั้งค่า Claude Code เมื่อเกิดปัญหา
    /debugช่วยค้นหาและอธิบายสาเหตุของปัญหา

    ดูรายละเอียดแต่ละคำสั่งด้านล่าง


    1️⃣ Part 1. Basic: คำสั่งพื้นฐานสำหรับเริ่มใช้ Claude Code

    12 คำสั่งในกลุ่มแรกเป็นคำสั่งพื้นฐานสำหรับเริ่มใช้งาน Claude Code และแบ่งเป็น 4 กลุ่มย่อยตามการเขียน code:

    1. เริ่มใช้งาน
    2. เขียน code
    3. รีวิวงาน
    4. ดูคู่มือ

    .

    🏁 Group 1. คำสั่งเริ่มใช้งาน

    👉 คำสั่งที่ 1. claude:

    เริ่ม session ใช้งาน Claude Code

    1 session เท่ากับ 1 ห้องแชทในการคุยกับ Claude

    ในแต่ละ session, Claude มีความจำที่แยกออกจากกัน ทำให้สิ่งที่เราคุยในแต่ละ session ไม่ปะปนกัน

    .

    👉 คำสั่งที่ 2. ! <command>:

    รัน shell command ระหว่างใช้งาน Claude Code

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 3. @<file>:

    ชี้ไฟล์ให้ Claude

    ใช้เวลาต้องการให้ Claude ทำงานกับไฟล์

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 4. /model:

    เลือก model ที่จะใช้งาน โดยมีให้เลือกระหว่าง:

    1. Haiku
    2. Sonnet
    3. Opus

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 5. /exit:

    ออกจาก session

    ใช้เวลาทำงานเสร็จแล้ว

    ตัวอย่าง:

    .

    💻 Group 2. คำสั่งสำหรับเขียน Code

    👉 คำสั่งที่ 6. /plan:

    เข้าโหมดวางแผน เพื่อกำหนดทิศทางการทำงานก่อนเขียน code จริง ซึ่งจะทำให้ Claude เขียน code ได้ตอบโจทย์มากขึ้น

    Note: กด shift + tab เพื่อเปลี่ยนโหมดได้เหมือนกัน

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 7. /init:

    ให้ Claude เขียน CLAUDE.md ซึ่งเป็นไฟล์ที่กำหนดบริบทการทำงาน จากการอ่านไฟล์ต่าง ๆ ใน folder ทำงานของเรา

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 8. /memory:

    เปิดดู CLAUDE.md เพื่อแก้ไข

    ตัวอย่าง CLAUDE.md:

    Markdown
    # Code style
    - Follow PEP 8; format with `black` before committing
    - Use type hints on all function signatures
    - Prefer pandas vectorized operations over row-wise loops
    # Workflow
    - Activate the venv with `source .venv/bin/activate` before running scripts
    - Run `pytest tests/` after any change to `src/`
    - Keep notebooks out of version control; convert final logic into `.py` modules

    .

    👉 คำสั่งที่ 9. /btw:

    คุยกับ Claude ระหว่างที่ Claude กำลังเขียน code

    ใช้เวลามีคำถามและไม่ต้องการรอให้ Claude ทำงานเสร็จ

    ตัวอย่าง:

    .

    🧐 Group 3. คำสั่งรีวิวงาน

    👉 คำสั่งที่ 10. /diff:

    ดูการเปลี่ยนแปลงของ code ที่เกิดขึ้น

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 11. /review:

    สั่งให้ Claude Code ตรวจ code และแนะนำการแก้ไขให้

    ตัวอย่าง:

    .

    💻 Group 4. คำสั่งสำหรับดูคู่มือ

    👉 คำสั่งที่ 12. /help:

    เปิดดูคำสั่งสำหรับใช้ Claude Code

    ตัวอย่าง:


    2️⃣ Part 2. Intermediate: คำสั่งเพิ่มประสิทธิภาพการทำงาน

    12 คำสั่งในกลุ่ม 2 ช่วยเพิ่มประสิทธิภาพการทำงานของ Claude Code และแบ่งได้เป็น 4 กลุ่มย่อย:

    1. คำสั่งจัดการ session
    2. คำสั่งจัดการ context
    3. คำสั่งตั้งค่า Claude Code
    4. คำสั่งดูการใช้งาน Claude Code

    .

    🗣️ Group 1. คำสั่งจัดการ Session

    👉 คำสั่งที่ 13. claude -c:

    กลับไปใช้ session ล่าสุด

    ใช้เมื่อเราออกจาก session และต้องการกลับเข้าไปใช้งานใหม่

    .

    👉 คำสั่งที่ 14. /resume:

    เปิดดูรายการ session ที่ผ่านมา

    ใช้เพื่อเลือก session ที่ต้องการกลับไปใช้งานต่อ

    .

    👉 คำสั่งที่ 15. /rename:

    เปลี่ยนชื่อ session เพื่อให้หา session ได้ง่ายขึ้น

    .

    💬 Group 2. คำสั่งจัดการ Context

    👉 คำสั่งที่ 16. /context:

    เปิดดู context ที่ถูกใช้ไปใน session เพื่อดูว่า Claude เหลือพื้นที่ความจำในการทำงานอีกเท่าไร

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 17. /compact:

    สรุปข้อมูลใน context เพื่อเพิ่มพื้นที่ในความจำให้กับ Claude

    ใช้เวลาต้องการเพิ่มความจำ โดยไม่เสียบริบทในการทำงานไป เช่น เวลาความจำเต็ม แต่ต้องการพัฒนา feature ที่มีอยู่ต่อ

    Note: ข้อเสีย คือ Claude จะจำรายละเอียดบางอย่างไม่ได้

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 18. /clear:

    ลบข้อมูลใน context ออกทั้งหมด

    ใช้สำหรับเพิ่มพื้นที่ความจำเวลาที่เราไม่ต้องการเก็บบริบทในการทำงานที่มีอยู่เอาไว้ เช่น เวลาจะพัฒนา feature ใหม่

    .

    🦾 Group 3. คำสั่งตั้งค่า Claude Code

    👉 คำสั่งที่ 19. /skills:

    เปิดดู skill ที่ Claude เข้าถึงได้

    ใช้จัดการ skill ที่ Claude เรียกใช้งานได้

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 20. /mcp:

    เปิดดู MCP (Model Context Protocol) หรือเครื่องมือที่ Claude เข้าถึงได้

    ใช้จัดการ MCP ที่ Claude เรียกใช้งานได้

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 21. /agents:

    เปิดดู subagent หรือสร้าง subagent ใหม่

    ใช้จัดการ subagent ที่ Claude เข้าถึงได้ หรือสร้าง subagent ใหม่ให้ Claude เรียกใช้งาน

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 22. /plugin:

    เปิดดู plugin ที่ Claude ใช้งานได้

    ใช้สำหรับจัดการ plugin ที่ Claude เรียกใช้งานได้

    ตัวอย่าง:

    .

    🪙 Group 4. คำสั่งดูการใช้งาน Claude Code

    👉 คำสั่งที่ 23. /usage:

    ดูจำนวนข้อความคงเหลือที่ยังใช้ได้

    .

    👉 คำสั่งที่ 24. /cost:

    ดูจำนวนเงินที่ใช้ไปกับการทำงาน Claude Code

    ตัวอย่าง:


    3️⃣ Part 3. Advanced: คำสั่งขั้นสูงสำหรับทำงานอัตโนมัติ

    8 คำสั่งขั้นสูงในกลุ่มสุดท้าย ใช้สำหรับสั่งให้ Claude ทำงานโดยอัตโนมัติ และแก้ปัญหาการใช้งาน Claude

    ทั้ง 8 คำสั่งแบ่งเป็น 2 กลุ่ม:

    1. คำสั่งสำหรับทำงานอัตโนมัติ
    2. คำสั่งแก้ปัญหาการใช้งาน Claude Code

    .

    🤖 Group 1. คำสั่งสำหรับทำงานอัตโนมัติ

    👉 คำสั่งที่ 25. /goal:

    กำหนดเป้าหมายที่ต้องการ โดย Claude Code จะทำงานไปเรื่อย ๆ จนกว่าเป้าหมายนี้จะสำเร็จ

    เหมาะกับงานที่ต้องการให้ Claude ทำไปเองจนกว่าจะเสร็จ

    .

    👉 คำสั่งที่ 26. /batch:

    สั่งให้ Claude Code แตกงานขนาดใหญ่ให้เป็นก้อนเล็ก ๆ และรันงานขนานกันไป เหมาะสำหรับการแก้ code หลายจุดพร้อมกัน

    .

    👉 คำสั่งที่ 27. /schedule:

    ตั้งเวลาที่จะให้ Claude Code ทำงานบางอย่าง

    เช่น ทดสอบ code ทุก 10 โมงเช้า

    .

    👉 คำสั่งที่ 28. /loop:

    สั่งให้ Claude Code ทำงานตามช่วงเวลาที่กำหนด

    เช่น ทดสอบ code ทุก ๆ 1 ชั่วโมง

    .

    👉 คำสั่งที่ 29. /background:

    ย้าย session ไปอยู่ใน background ซึ่งจะทำให้เราใช้ Terminal ได้ในขณะที่ Claude Code ยังทำงานอยู่

    .

    👉 คำสั่งที่ 30. /tasks:

    เปิดดูรายการ session ที่รันอยู่ใน background

    ตัวอย่าง:

    .

    🩺 Group 2. คำสั่งแก้ปัญหาการใช้งาน Claude Code

    👉 คำสั่งที่ 31. /doctor:

    ตรวจสอบการตั้งค่า Claude Code เวลามีปัญหา

    ตัวอย่าง:

    .

    👉 คำสั่งที่ 31. /debug:

    สั่งให้ Claude Code ค้นหาและอธิบายเหตุของปัญหา


    🫵 Your Turn

    หลังจบบทความนี้แล้ว ลองมาใช้ Claude Code กันดูนะครับ:


    📃 References

    Fediverse Reactions
  • สรุป 25 บทเรียนจาก 5 เวทีที่น่าสนใจ ในงาน “How Do I Live? อยู่อย่างไร เมื่อ AI ล้อมไว้หมดแล้ว”: What to Build, Writing, Creativity, AI Can Free Up Time, & Philosophy

    สรุป 25 บทเรียนจาก 5 เวทีที่น่าสนใจ ในงาน “How Do I Live? อยู่อย่างไร เมื่อ AI ล้อมไว้หมดแล้ว”: What to Build, Writing, Creativity, AI Can Free Up Time, & Philosophy

    “How Do I Live? อยู่อย่างไร เมื่อ AI ล้อมไว้หมดแล้ว” เป็นงานที่รวม speaker มาตอบคำถามที่หลาย ๆ คนอาจจะสงสัย ว่าในยุคที่ AI ทำได้เกือบเหมือนมนุษย์ทุกอย่าง เราจะอยู่ยังไง

    ในบทความนี้ ผมจะมาสรุป 25 บทเรียนจาก 5 เวทีที่น่าสนใจในงาน ที่จะตอบคำถามนี้กัน

    โดยบทความแบ่งออกเป็น 5 ส่วน:

    1. What to build
    2. Writing
    3. Creativity
    4. AI can free up time
    5. Philosophy

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    🤨 Session 1. What to Build

    จาก “ถ้าคุณสร้างอะไรก็ได้ คุณจะสร้างอะไร” โดย สิทธินันท์ พลวิสุทธิ์ศักดิ์ (แบงค์)

    .

    🔶 Lesson 1. AI Can Build Anything. Doesn’t Mean Everything Should be Built

    AI สร้างอะไรให้เราก็ได้

    แค่เรารู้ว่าต้อง prompt ยังไง เราก็จะได้สิ่งที่ต้องการภายในไม่กี่คลิก

    แต่เพียงเพราะเราสร้างได้ ไม่ได้หมายความว่า เราจะต้องสร้าง

    และไม่ได้หมายความว่า ทุกอย่างจะสร้างง่ายเหมือนเสกได้

    .

    🔶 Lesson 2. TADA: Challenges to Building With AI

    การสร้างด้วย AI มีความท้าทาย 4 ข้อ:

    ข้อ 1. T = Technical difficulties:

    • เราต้องมีความรู้ทางเทคนิค
    • ต้องรู้ว่าสิ่งที่ AI สร้างขึ้นเกิดขึ้นได้ยังไง
    • เช่น ให้ AI สร้างเว็บไซต์ เราต้องมีความรู้เกี่ยวกับ domain, server, hosting, etc.

    ข้อ 2. A = Acquisition channel:

    • สร้างได้ ≠ จะมีคนใช้
    • ถ้าเราไม่มีช่องทางเข้าถึง หรือของไม่ตอบโจทย์ สิ่งที่สร้างมาก็ไร้ความหมาย

    ข้อ 3. D = Domain expertise:

    • เราต้องมีความรู้ในสิ่งที่สร้าง
    • เช่น ถ้าเราจะสร้าง medical chatbot เราต้องมีความรู้ทางการแพทย์มากพอที่จะตรวจสอบ bot ของเราได้

    ข้อ 4. A = Authority:

    • เราต้องมีความน่าเชื่อถือมากพอ เพื่อให้สิ่งที่เราสร้างดูน่าเข้าหา

    .

    🔶 Lesson 3. KEY: What You Should Build With AI

    สิ่งที่เราควรสร้างกับ AI มีอยู่ 3 อย่าง:

    ข้อ 1. K = Knowledge:

    • ความรู้ที่จะช่วยให้เราก้าวไปข้างหน้าอยู่เสมอ

    ข้อ 2. E = Engine:

    • ใช้ AI ต่อยอดสิ่งที่เรามี

    ข้อ 3. Y = Why:

    • ใช้ AI ค้นหาคุณค่าของสิ่งที่ต้องสร้าง

    .

    🔶 Lesson 4. Focus on Wealth

    AI ควรช่วยสร้าง wealth ให้กับเรา ไม่ว่าจะเป็น:

    ข้อ 1. Time:

    • อิสระในการเลือกใช้เวลาด้วยตัวเอง

    ข้อ 2. Social:

    • ความสัมพันธ์ทางสังคมที่ดี

    ข้อ 3. Mental:

    • ความสงบในจิตใจและศักยภาพในการเติบโต

    ข้อ 4. Physical:

    • สุขภาพทางกายที่ดี

    ข้อ 5. Financial:

    • ความร่ำรวยทางการเงิน

    .

    🔶 Lesson 5. Takeaway on What to Build

    ข้อ 1. Process over result:

    • Focus ที่ขั้นตอนและกระบวนการมากกว่าผลลัพธ์ที่ได้

    ข้อ 2. Bite size:

    • หาโจทย์ที่ทำได้พอตัว ไม่ต้องเป็นโจทย์ที่เปลี่ยนโลก

    ✏️ Session 2. Writing

    จาก “เขียนให้ชนะ AI” โดย วีรยา ถาวรวัฒนยงค์ (ลุงพล)

    .

    🔶 Lesson 6. Human Writing Can Still Win

    ในยุคที่ AI สร้าง content ได้ง่ายและเร็ว และคนมี short attention span การเขียน long-form ยังสร้าง engagement และรายได้หลักล้านได้

    .

    🔶 Lesson 7. The Secret Formula

    สูตรสำเร็จในการเขียน คือ

    PVE^2

    .

    🔶 Lesson 8. P for Process

    เน้นที่ขั้นตอน/กระบวนการ ไม่ใช่ผลลัพธ์

    แม้ AI สร้างรูปได้สวยและหลากหลาย แต่ก็สู้เอกลักษณ์ของจิตรกรที่นั่งลงพู่กันในงานแต่งสด ๆ ไม่ได้

    .

    🔶 Lesson 9. V for Value

    คุณค่าที่ต้องการส่งต่อ

    อย่างในกรณีลุงพล คือ การส่งต่อสรุปเนื้อหาดี ๆ ถึงคนที่ไม่ได้เข้าร่วมงาน ให้เหมือนได้ไปอยู่ในงานด้วยตัวเอง

    .

    🔶 Lesson 10. E1 for Experiences

    งานเขียนขึ้นอยู่กับประสบการณ์ที่นักเขียนถ่ายทอดลงในงานเขียน

    ประสบการณ์ของมนุษย์เป็นสิ่งที่ AI ยัง copy ไม่ได้ และเป็นสิ่งที่สร้าง individuality ให้กับงานเขียนของเรา

    .

    🔶 Lesson 11. E2 for Empathy

    ตัวแปรสุดท้ายในสมการลับ คือ empathy

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


    🎨 Session 3. Creativity

    จาก “AI Is the End of Human Creativity” โดย สิทธิพงศ์ ศิริมาศเกษม

    .

    🔶 Lesson 12. Will AI Replace Human Creativity?

    Creativity ของมนุษย์ยังคงมีที่ยืนในยุคที่ AI สร้างงานที่มนุษย์ใช้เวลาครึ่งวันทำได้ภายใน 3 นาที ด้วยเหตุผล 3 ข้อ:

    1. Slow/stop, not fast
    2. Question, not answer
    3. Quality, not quantity

    .

    🔶 Lesson 13. Slow/Stop, Not Fast

    Creativity ไม่ได้เกิดจากความเร็ว

    แต่เกิดจากการคิดให้ช้าหรือหยุดคิด

    ความคิดดี ๆ มักจะเกิดขึ้นตอนที่เราไม่ได้จดจ่อกับงาน แต่ออกไปเดินเล่นหรือทำกิจกรรมอื่น

    .

    🔶 Lesson 14. Question, Not Answer

    Creativity ไม่ได้เกิดจากคำตอบ

    แต่มาจากการตั้งคำถามที่ดี

    .

    🔶 Lesson 15. Quality, Not Quantity

    AI สามารถคิด option จำนวนมากให้เราได้ภายในเวลาอันสั้น

    แต่ creativity ไม่ได้เกิดจากจำนวนของ option

    แต่จากการคัดกรองไอเดียที่ใช่และเชื่อมโยงกัน

    .

    🔶 Lesson 16. AI = Adaptability Intelligence

    แม้ AI จะมาแทน human creativity ไม่ได้ แต่ AI ช่วยให้เราพัฒนาและปรับตัวเข้ากับยุคต่าง ๆ ได้

    ในมุมนี้ AI จะไม่ใช่ artificial intelligence แต่เป็น adaptability intelligence

    .

    🔶 Lesson 17. Think Outside the Bot

    ในยุคที่ AI คิดแทนเราได้ สิ่งที่จะทำให้เราแตกต่างออกไป คือ การคิดนอกบอท

    นั่นคือ การคิดด้วยตัวเอง และไม่พึ่งพา AI จนมากเกินไป


    🕦 Session 4. AI Can Free Up Time

    จาก “How AI Helps Startups: สร้างธุรกิจให้เร็วขึ้นด้วย AI” โดย อภิญญา สหัสสะรังษี (พลอย Paypers)

    .

    🔶 Lesson 18. AI Can Free Up Time

    เป็นครั้งแรกในประวัติศาสตร์มนุษย์ที่เทคโนโลยีเอางานไปจากเรา

    AI ช่วยลดงานและคืนเวลาในชีวิตให้กับเราได้

    .

    🔶 Lesson 19. Paypers as Example

    ตัวอย่างเช่น Paypers ที่ช่วยจัดเก็บและทำเอกสารบัญชี ช่วยลดงาน routine และปล่อยเวลา 30–60% ให้กับเจ้าของธุรกิจได้ทำงานที่มีคุณค่ามากกว่า เช่น:

    • หาไอเดียใหม่ ๆ
    • วางแผน วางระบบให้ธุรกิจเติบโต

    .

    🔶 Lesson 20. Next Question After AI

    คำถามที่ตามมาจากการที่ AI ปลดงานออกจากเรา คือ เราจะใช้เวลาที่ได้มาไปกับอะไร?


    🧘 Session 5. Philosophy

    จาก “One Person Business: ธุรกิจคนเดียวที่ไม่ทำคนเดียว” โดย อานันท์ ตรีฐิติพัฒน์, กษิดิศ สตางค์มงคล, และทีปกร วุฒิพิทยามงคล

    .

    🔶 Lesson 21. Agency

    Agency คือ ความสามารถในการเลือกทางเดินของตัวเอง

    คนเราเกิดมาพร้อมกับ agency ไม่ว่าจะกินจะนอนเวลาไหนก็ไม่มีใครสั่งเราได้

    แต่สังคมหล่อหลอมให้เรากลายเป็น version ที่มี agency น้อยลง

    .

    🔶 Lesson 22. What to Choose

    ถ้าจะต้องเลือกทางเดิน เราจะเลือกไปทางไหน?

    คำตอบมีอยู่ 3 อย่าง:

    1. What feels like play
    2. What’s right
    3. Better version of yourself

    .

    🔶 Lesson 23. What Feels Like Play

    เลือกทำในสิ่งที่เป็นเหมือนการเล่นสำหรับเรา แต่เป็นงานสำหรับคนอื่น

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

    Find what feels like play to you, but looks like work to others. — Naval Ravikant

    .

    🔶 Lesson 24. Do What’s Right

    ทำในสิ่งที่ถูกต้อง เพราะสิ่งที่ไม่ดีกับส่วนรวมก็ไม่ดีกับปัจเจกบุคคล และสิ่งที่เราทำจะกลับมาหาเราเอง

    What brings no benefit to the hive brings none to the bee. — Marcus Aurelius

    .

    🔶 Lesson 25. Become the Best Version of Yourself

    ทำสิ่งที่จะทำให้เราเป็น version ที่ดีขึ้นของตัวเองในทุก ๆ วัน

    There is nothing noble in being superior to your fellow man; true nobility is being superior to your former self. — Ernest Hemingway

  • วิธีใช้ Haystack 2.0 เชื่อมต่อ LLM ด้วย Python ใน 4 ขั้นตอน

    วิธีใช้ Haystack 2.0 เชื่อมต่อ LLM ด้วย Python ใน 4 ขั้นตอน

    ในบทความก่อน ผมพาทุกคนไปรู้จักกับการใช้ LangChain ซึ่งเป็น package ยอดนิยมสำหรับสร้าง LLM (large language model) application อย่าง chatbot

    ในบทความนี้ ผมจะพาทุกคนไปรู้จักกับ Haystack 2.0 ซึ่งเป็นอีกหนึ่ง package ที่ทำงานได้เหมือนกับ LangChain

    แม้ว่า LangChain เป็นที่นิยมและใช้งานง่าย แต่ก็แลกมาด้วยข้อจำกัดใน “การมองเห็น” เพราะ LangChain ซ่อนการทำงานหลาย ๆ อย่างไว้หลัง code ไม่กี่บรรัดเพื่อให้เราใช้งานง่าย เมื่อเกิด bug ขึ้นมา เราจะไม่รู้เลยว่า error อยู่ที่จุดไหน จนกว่าเราจะแกะการทำงานเบื้องหลัง code ที่เราเขียนออกมา

    Haystack เป็น package ที่มี “การมองเห็น” ที่สูงกว่า เพราะมีการทำงานแบบแยกส่วนประกอบ หรือ component เหมือนกับรถยนต์ที่ประกอบขึ้นมาจากหลายชิ้นส่วน อย่างเครื่องยนต์ ถังน้ำมัน ล้อ และพวงมาลัย เราสามารถกำหนดได้ว่า เราอยากได้ชิ้นส่วนไหนแบบไหน และแต่ละชิ้นส่วนจะประกอบกันยังไง เมื่อเป็นเช่นนี้ เราจะรู้ได้ว่าข้อผิดพลาดอยู่ที่ไหน เพราะเราเป็นคนที่ประกอบทุกอย่างขึ้นมาเอง

    ในบทความนี้ ผมจะพาทุกคนไปดูการใช้ Haystack เพื่อเชื่อมต่อกับ LLM ผ่านตัวอย่างการสร้าง AI ตอบคำถามเกี่ยวกับ mental model กัน

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    ⭐️ High-Level View

    ในการใช้ Haystack เชื่อมต่อกับ LLM เราจะใช้ component 3 อย่าง:

    1. Prompt builder สำหรับเก็บ prompt
    2. LLM instance สำหรับเรียก LLM
    3. Pipeline สำหรับเชื่อมทุก component เข้าด้วยกัน

    โดยเราจะเรียกใช้งาน 3 components นี้ใน 4 ขั้นตอน:

    1. Create a prompt builder
    2. Create an LLM instance
    3. Create a pipeline
    4. Run

    ไปดูตัวอย่างทั้ง 4 ขั้นตอนกัน


    📜 Step 1. Create a Prompt Builder

    ในขั้นแรก เราจะสร้าง prompt builder สำหรับเก็บ prompt กัน

    เราจะเริ่มจากสร้าง system prompt และ user prompt:

    Python
    # System prompt
    system_prompt = """
    You are an expert curator of mental models across science, philosophy, and applied reasoning.
    Your task is to explain mental models clearly and accurately using a fixed schema.
    If the origin of a model is unclear or debated, state that explicitly.
    Do not invent historical sources. Be concise and concrete.
    """
    # User prompt
    user_prompt = "Explain the following mental model: {{model_query}}"

    Note: เราใช้ {{}} ใน user prompt เพื่อที่เราจะสร้างแทนที่ค่าใน user prompt ได้ในภายหลัง เช่น ถ้าเราต้องการถามเกี่ยวกับ “First-Principles Thinking” user prompt ของเราก็จะกลายเป็น:

    "Explain the following mental model: First-Principles Thinking"

    จากนั้น เราจะใส่ prompts ลงใน ChatPromptBuilder():

    Python
    # Import required packages
    from Haystack.components.builders import ChatPromptBuilder
    from Haystack.dataclasses import ChatMessage
    # Create a prompt builder instance
    prompt_builder = ChatPromptBuilder(
    template=[
    ChatMessage.from_system(system_prompt.strip()),
    ChatMessage.from_user(user_prompt)
    ],
    required_variables=["model_query"]
    )

    Note: เรากำหนด required_variables เพื่อกันไม่ให้ {{model_query}} เป็นค่าว่าง


    🤖 Step 2. Create an LLM Instance

    ในขั้นที่ 2 เราจะสร้าง LLM instance สำหรับเชื่อมต่อกับ LLM โดยในตัวอย่าง เราจะใช้ Gemini

    เราจะเริ่มจากดึง API key ที่เก็บไว้ใน .env:

    Python
    # Import required packages
    import os
    # Retrieve the API key
    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")

    จากนั้น กำหนด structured output หรือหน้าตา output ที่เราต้องการ ด้วย Pydantic:

    Python
    # Import required packages
    from pydantic import BaseModel, Field
    from typing import List, Literal
    # Define the output schema
    class MentalModel(BaseModel):
    # Mental model name
    model_name: str = Field(
    description="The commonly accepted name of the mental model"
    )
    # Origin or source
    origin: str = Field(
    description="Where the model comes from (a person, book, field, or cultural origin)"
    )
    # Brief description
    description: str = Field(
    description="A brief explanation of what the mental model is and why it matters"
    )
    # Example
    example: str = Field(
    description="A concrete real-world example illustrating the mental model"
    )
    # Tags
    tags: List[str] = Field(
    description="Short tags such as decision-making, systems thinking, learning, and philosophy"
    )

    หน้าตา structured output ที่เราจะได้:

    {
    "model_name": "",
    "origin": "",
    "description": "",
    "example": "",
    "tags": []
    }

    สุดท้าย เราจะใส่ API key และ structured output ลงใน LLM instance:

    Python
    # Import required packages
    from Haystack.utils import Secret
    from Haystack_integrations.components.generators.google_genai import GoogleGenAIChatGenerator
    # Create an LLM instance
    llm_with_structured_output = GoogleGenAIChatGenerator(
    model="gemini-2.5-flash",
    api_key=Secret.from_token(GEMINI_API_KEY),
    generation_kwargs={
    "temperature": 0.5,
    "response_format": MentalModel
    }
    )

    🪈 Step 3. Create a Pipeline

    ในขั้นที่ 3 เราจะเชื่อมต่อ prompt builder และ LLM instance เข้าด้วยกัน

    เริ่มจากสร้าง pipeline:

    Python
    # Import the required package
    from Haystack import Pipeline
    # Create a pipeline instance
    chain = Pipeline()

    เพิ่ม prompt builder และ LLM instance ลงใน pipeline:

    Python
    # Add the prompt builder and LLM instances
    chain.add_component(
    "prompt_builder", # Name
    prompt_builder # Instance
    )
    chain.add_component(
    "llm", # Name
    llm_with_structured_output # Instance
    )

    แล้วเชื่อมต่อ prompt builder และ LLM instance เข้าด้วยกัน:

    Python
    # Connect the components
    chain.connect(
    "prompt_builder.prompt", # Sender: prompt from prompt builder
    "llm.messages" # Receiver: message from LLM instance
    )

    Note: เรากำหนดให้ prompt builder ส่ง system และ user prompts ให้เป็น input สำหรับ LLM instance:

    Prompt FROM prompt builder
    Messages TO LLM instance

    🏃 Step 4. Run

    ในขั้นสุดท้าย เราจะรัน pipeline และดึงผลลัพธ์ที่ต้องการออกมา

    ตัวอย่างเช่น ถามเกี่ยวกับ “Compound Interest”:

    Python
    # Run the pipeline with a mental-model query
    raw_result = chain.run(
    data={
    "prompt_builder": {"model_query": "Compound Interest"}
    }
    )

    ดึงผลลัพธ์ที่ต้องการ:

    Python
    # Extract the structured-output text from the raw result
    reply_json = raw_result["llm"]["replies"][0].text
    # Validate the structured output
    result = MentalModel.model_validate_json(reply_json)
    # Print the validated structured output
    print(result.model_dump())

    ผลลัพธ์:

    {
    "model_name": "Compound Interest",
    "origin": (
    "Finance, Mathematics. The concept dates back to ancient Mesopotamia, "
    "with formalization in mathematics and finance over centuries."
    ),
    "description": (
    "Compound interest is the interest on a loan or deposit calculated "
    "based on both the initial principal and the accumulated interest from "
    "previous periods. It matters because it illustrates exponential growth, "
    "where small, consistent gains over time lead to significantly larger "
    "returns, making it a powerful force in finance and many other systems."
    ),
    "example": (
    "If you invest $1,000 at a 5% annual interest rate, after one year "
    "you have $1,050. In the second year, you earn 5% not just on the "
    "initial $1,000, but on the full $1,050, resulting in $1,102.50. "
    "This 'interest on interest' accelerates growth significantly over "
    "decades compared to simple interest."
    ),
    "tags": [
    "Finance",
    "Growth",
    "Long-term thinking",
    "Mathematics",
    "Systems thinking",
    ],
    }

    💪 Summary

    ในบทความนี้ เราได้ทำความรู้จักกับ Haystack ซึ่งเป็น package สำหรับสร้าง LLM application กัน

    เราได้เรียนเกี่ยวกับ 3 components สำหรับเชื่อมต่อกับ LLM:

    1. Prompt builder
    2. LLM instance
    3. Pipeline

    และการเชื่อมต่อกับ LLM ใน 4 ขั้นตอน:

    1. Create a prompt builder
    2. Create an LLM instance
    3. Create a pipeline
    4. Run

    😺 GitHub

    ดูตัวอย่าง code ทั้งหมดได้ที่ GitHub


    📃 References

    Fediverse Reactions
  • วิธีใช้ LangChain สร้าง RAG Pipeline ใน 5 ขั้นตอน

    วิธีใช้ LangChain สร้าง RAG Pipeline ใน 5 ขั้นตอน

    RAG (Retrieval-Augmented Generation) เป็นเทคนิคที่ช่วยให้ LLM (large language model) ตอบคำถามได้แม่นยำขึ้น และไม่ถูกจำกัดด้วย knowledge cutoff หรือความรู้ที่จำกัดจากตอน train model

    RAG ทำงานใน 2 ขั้นตอน:

    1. Retrieve: ดึงเอกสารที่เกี่ยวข้อง
    2. Generate: สร้างคำตอบจากเอกสารที่ได้มา

    RAG มีข้อดี 3 ข้อ:

    1. คำตอบมีความแม่นยำมากขึ้น
    2. คำตอบมีความเกี่ยวข้องกับคำถามมากขึ้น
    3. ช่วยอัปเดตความรู้ให้กับ LLM ได้โดยไม่ต้อง train model ใหม่

    ในบทความนี้ เราจะมาดูวิธีการสร้าง RAG pipeline ด้วย LangChain ซึ่งเป็น framework ในการพัฒนาแอปพลิเคชัน LLM กัน

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    🔆 Overview

    เราใช้ LangChain สร้าง RAG pipeline ได้ใน 5 ขั้นตอน

    1. Load documents
    2. Split text
    3. Embed and store chunks
    4. Create a retriever
    5. Generate a response

    เราไปดูการสร้าง RAG pipeline กับตัวอย่างบอทตอบคำถามเกี่ยวกับนโยบาย HR เช่น การลาและสวัสดิ กัน


    📑 Step 1. Load Documents

    ในขั้นแรก เราจะโหลดเอกสารที่เป็นข้อมูลของ RAG pipeline ก่อน

    LangChain มีหลาย functions สำหรับโหลดเอกสาร เช่น:

    FunctionDocument
    TextLoader()Text file
    UnstructuredMarkdownLoader()Markdown file
    CSVLoader()CSV file
    JSONLoader()JSON file
    PyPDFLoader()PDF file
    DirectoryLoader()ไฟล์จากในโฟลเดอร์

    ในตัวอย่าง เราจะใช้ DirectoryLoader() เพราะเราเก็บเอกสารไว้ในโฟลเดอร์ชื่อ documents:

    documents/
    ├── benefits_policy.txt
    ├── compensation_policy.txt
    ├── leave_policy.txt
    └── remote_work_policy.txt

    ตัวอย่างข้อมูลในเอกสาร benefits_policy.txt:

    DataWise Co. Benefits Policy
    Full-time employees receive health insurance after completing probation.
    The company provides annual health checkups once per year.
    Employees can claim up to 2,000 THB per month for wellness activities such as fitness memberships, yoga classes, or mental health support.
    Employees are also eligible for learning support. The company reimburses up to 10,000 THB per year for approved online courses, books, or professional certificates.

    วิธีใช้ DirectoryLoader():

    Python
    # Import packages
    from langchain_community.document_loaders import DirectoryLoader
    from langchain_community.document_loaders import TextLoader
    # Initialise loader
    loader = DirectoryLoader(
    path="documents",
    glob="*.txt",
    loader_cls=TextLoader,
    loader_kwargs={"encoding": "utf-8"}
    )
    # Load documents
    docs = loader.load()

    การใช้งาน DirectoryLoader():

    • path = โฟลเดอร์ที่ต้องการโหลด
    • glob = pattern ชื่อไฟล์ที่ต้องการโหลด (เช่น "*.txt" หมายถึง ไฟล์ที่ลงชื่อด้วย .txt ทั้งหมด)
    • loader_cls = function ที่จะใช้โหลด (เช่น TextLoader())
    • loader_kwargs = argument เพิ่มเติมสำหรับ function ที่จะใช้โหลด

    เราสามารถดูตัวอย่างเอกสารที่โหลดแล้วได้แบบนี้:

    Python
    # View loaded documents
    for doc in docs:
    print("=" * 50)
    print(doc.metadata["source"])
    print("=" * 50)
    print(doc.page_content[:200])

    ผลลัพธ์:

    ==================================================
    documents/remote_work_policy.txt
    ==================================================
    DataWise Co. Remote Work Policy
    Employees may work from home up to 2 days per week.
    Remote work must be approved by the employee's direct manager.
    Employees must be reachable on Slack during core w
    ==================================================
    documents/benefits_policy.txt
    ==================================================
    DataWise Co. Benefits Policy
    Full-time employees receive health insurance after completing probation.
    The company provides annual health checkups once per year.
    Employees can claim up to 2,000 THB
    ==================================================
    documents/compensation_policy.txt
    ==================================================
    DataWise Co. Compensation Policy
    Salary is paid on the last working day of each month.
    Performance bonuses are reviewed once per year in December.
    Employees may receive an annual salary adjustment
    ==================================================
    documents/leave_policy.txt
    ==================================================
    DataWise Co. Leave Policy
    Full-time employees receive 10 days of annual leave per year after completing probation.
    Employees receive 15 days of paid sick leave per year.
    Sick leave of 3 consecutive

    📚 Step 2. Split Text

    ในขั้นที่ 2 เราจะแบ่ง text ในเอกสารออกเป็นก้อน ๆ หรือ chunk เพราะการแบ่ง text จะช่วยให้การค้นหาข้อมูลง่ายขึ้น

    LangChain มี 3 functions หลักในการแบ่ง text:

    FunctionMethod
    CharacterTextSplitter()แบ่งตามจำนวน character ที่กำหนด
    TokenTextSplitter()แบ่งตามจำนวน token ที่กำหนด
    RecursiveCharacterTextSplitter()แบ่งตามย่อหน้า บรรทัด และประโยค

    ในตัวอย่าง เราจะใช้ RecursiveCharacterTextSplitter() เพราะเป็นวิธีที่เก็บรักษาความหมายของ text ได้ดีกว่าวิธีอื่น:

    วิธีใช้ RecursiveCharacterTextSplitter():

    Python
    # Import package
    from langchain_text_splitters import RecursiveCharacterTextSplitter
    # Create splitter
    text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=100
    )
    # Split documents
    chunks = text_splitter.split_documents(docs)

    ดูตัวอย่าง text ที่แบ่งแล้วได้ตามนี้:

    Python
    # View results
    for i, chunk in enumerate(chunks[:5]):
    print(f"Chunk {i+1}")
    print("Source:", chunk.metadata["source"])
    print(chunk.page_content)
    print("-" * 50)

    ผลลัพธ์:

    Chunk 1
    Source: documents/remote_work_policy.txt
    DataWise Co. Remote Work Policy
    Employees may work from home up to 2 days per week.
    Remote work must be approved by the employee's direct manager.
    Employees must be reachable on Slack during core working hours from 10:00 AM to 4:00 PM.
    Employees working remotely are responsible for maintaining a stable internet connection and a quiet work environment.
    New employees may request remote work only after completing their first month.
    --------------------------------------------------
    Chunk 2
    Source: documents/benefits_policy.txt
    DataWise Co. Benefits Policy
    Full-time employees receive health insurance after completing probation.
    The company provides annual health checkups once per year.
    Employees can claim up to 2,000 THB per month for wellness activities such as fitness memberships, yoga classes, or mental health support.
    Employees are also eligible for learning support. The company reimburses up to 10,000 THB per year for approved online courses, books, or professional certificates.
    --------------------------------------------------
    Chunk 3
    Source: documents/compensation_policy.txt
    DataWise Co. Compensation Policy
    Salary is paid on the last working day of each month.
    Performance bonuses are reviewed once per year in December.
    Employees may receive an annual salary adjustment based on company performance, individual performance, and market benchmarks.
    Overtime pay is available only for non-managerial employees and must be approved by a manager before the overtime work begins.
    --------------------------------------------------
    Chunk 4
    Source: documents/leave_policy.txt
    DataWise Co. Leave Policy
    Full-time employees receive 10 days of annual leave per year after completing probation.
    Employees receive 15 days of paid sick leave per year.
    Sick leave of 3 consecutive days or more requires a medical certificate.
    Employees should submit annual leave requests at least 7 days in advance through the HR system.
    Unused annual leave can be carried over for up to 5 days into the next calendar year.
    --------------------------------------------------

    สังเกตว่า text ถูกแบ่งย่อหน้า ทำให้ chunk ที่ได้มีความหมายที่ครบถ้วนในตัวเอง


    💾 Step 3. Embed & Store Chunks

    ในขั้นที่ 3 เราจะ embed และเก็บข้อมูลลงใน vector database

    Embedding คือ การแปลง chunk ให้กลายเป็น vector คือ ชุดตัวเลขที่เป็นตัวแทนของ chunk

    ตัวอย่าง chunk:

    "Employees can work from home up to two days per week."

    ตัวอย่าง vector:

    [
    0.021,
    -0.184,
    0.736,
    0.094,
    -0.511,
    0.302,
    0.087,
    -0.624
    ]

    Vector เป็นสิ่งที่ระบบจะใช้ในการค้นหาเอกสารที่เกี่ยวข้อง โดย vector ที่มีความหมายใกล้เคียงกัน จะมีตัวเลขที่ใกล้เคียงกัน เมื่อเราต้องการหาเอกสาร ระบบจะดึงเอกสารที่มี vector ใกล้เคียงกับคำถามของเราขึ้นมาให้

    ใน LangChain เราสามารถเลือก model ที่จะใช้ embedding ได้ ในตัวอย่าง เราจะใช้ Gemini กัน:

    Python
    # Import packages
    import os
    from langchain_google_genai import GoogleGenerativeAIEmbeddings
    # Get API key
    GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
    # Create embedder
    document_embedder = GoogleGenerativeAIEmbeddings(
    model="gemini-embedding-001",
    task_type="retrieval_document",
    google_api_key=GEMINI_API_KEY
    )

    หลังจากได้ embedding model แล้ว เราจะสร้าง vector database เพื่อเก็บ vector โดยในตัวอย่างเราจะใช้ FAISS database:

    Python
    # Import package
    from langchain_community.vectorstores import FAISS
    # Build vector DB
    vectorstore = FAISS.from_documents(
    documents=chunks,
    embedding=document_embedder
    )

    สังเกตว่า เราใส่ document_embedder ไปใน vector database ด้วย เพื่อแปลง chunk เป็น vector และเก็บลงใน database


    🔎 Step 4. Create a Retriever

    ในขั้นที่ 4 เราจะสร้าง retriever ที่ทำหน้าที่ค้นหา vector โดยใช้ .as_retriever() แบบนี้:

    Python
    # Creater retriever
    retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 2}
    )

    เราสามารถทดสอบ retriever เพื่อดูว่า จะได้เอกสารอะไรกลับมา ได้แบบนี้:

    Python
    # Test retriever
    question = "Do I need a medical certificate for sick leave?"
    relevant_docs = retriever.invoke(question)
    for i, doc in enumerate(relevant_docs, start=1):
    print(f"Retrieved chunk {i}")
    print("Source:", doc.metadata["source"])
    print(doc.page_content)
    print("-" * 60)

    ผลลัพธ์:

    Retrieved chunk 1
    Source: documents/leave_policy.txt
    DataWise Co. Leave Policy
    Full-time employees receive 10 days of annual leave per year after completing probation.
    Employees receive 15 days of paid sick leave per year.
    Sick leave of 3 consecutive days or more requires a medical certificate.
    Employees should submit annual leave requests at least 7 days in advance through the HR system.
    Unused annual leave can be carried over for up to 5 days into the next calendar year.
    ------------------------------------------------------------
    Retrieved chunk 2
    Source: documents/compensation_policy.txt
    DataWise Co. Compensation Policy
    Salary is paid on the last working day of each month.
    Performance bonuses are reviewed once per year in December.
    Employees may receive an annual salary adjustment based on company performance, individual performance, and market benchmarks.
    Overtime pay is available only for non-managerial employees and must be approved by a manager before the overtime work begins.
    ------------------------------------------------------------

    🤖 Step 5. Generate a Response

    ในขั้นสุดท้าย เราจะให้ LLM สร้างคำตอบโดยใช้ข้อมูลใน vector database

    ในตัวอย่างเราจะลองใช้ Gemini ช่วยคิดคำตอบให้กับเรา

    เราจะเริ่มจากเชื่อมต่อกับ Gemini และสร้าง prompt ก่อน:

    Python
    # Import packages
    from langchain_google_genai import ChatGoogleGenerativeAI
    from langchain_core.prompts import ChatPromptTemplate
    # Initialise Gemini
    llm = ChatGoogleGenerativeAI(
    model="gemini-2.5-flash",
    temperature=0,
    google_api_key=GEMINI_API_KEY
    )
    # Create prompt template
    prompt = ChatPromptTemplate.from_template("""
    You are an HR policy assistant.
    Answer the user's question using only the policy context below.
    Rules:
    - Do not use outside knowledge.
    - If the answer is not in the context, say:
    "I could not find this information in the available company policies."
    - Keep the answer concise.
    - Mention the source policy file when possible.
    Policy context:
    {context}
    User question:
    {question}
    """)

    จากนั้น กำหนดคำถามและดึงเอกสารที่เกี่ยวข้องจาก vector database

    Python
    # Ask a question
    question = "Do I need a medical certificate for sick leave?"
    # Retrieve relevant document chunks
    relevant_docs = retriever.invoke(question)
    # Combine retrieved chunks into one context string
    context = "\n\n".join(
    [
    f"Source: {doc.metadata['source']}\n"
    f"{doc.page_content}"
    for doc in relevant_docs
    ]
    )
    # Inspect retrieved context before sending it to Gemini
    print("Retrieved context:")
    print(context)

    ผลลัพธ์:

    Retrieved context:
    Source: documents/leave_policy.txt
    DataWise Co. Leave Policy
    Full-time employees receive 10 days of annual leave per year after completing probation.
    Employees receive 15 days of paid sick leave per year.
    Sick leave of 3 consecutive days or more requires a medical certificate.
    Employees should submit annual leave requests at least 7 days in advance through the HR system.
    Unused annual leave can be carried over for up to 5 days into the next calendar year.
    Source: documents/compensation_policy.txt
    DataWise Co. Compensation Policy
    Salary is paid on the last working day of each month.
    Performance bonuses are reviewed once per year in December.
    Employees may receive an annual salary adjustment based on company performance, individual performance, and market benchmarks.
    Overtime pay is available only for non-managerial employees and must be approved by a manager before the overtime work begins.

    แล้วส่งข้อมูลคำถามและเอกสารให้กับ Gemini:

    Python
    # Add context and question to prompt template
    messages = prompt.invoke(
    {
    "context": context,
    "question": question
    }
    )
    # Send prompt to Gemini
    response = llm.invoke(messages)
    # Print Gemini's answer
    print(response.content)

    ผลลัพธ์:

    Yes, sick leave of 3 consecutive days or more requires a medical certificate. (Source: documents/leave_policy.txt)

    เพื่อให้เราใช้งาน RAG pipeline ได้ง่าย เราสามารถแปลงโค้ดชุดนี้ให้เป็น function ได้:

    Python
    # Convert to function
    def ask_policy_question(question: str) -> str:
    """
    Retrieve relevant policy chunks, send them to Gemini,
    and return Gemini's answer.
    """
    # Retrieve relevant chunks
    relevant_docs = retriever.invoke(question)
    # Combine retrieved chunks into context
    context = "\n\n".join(
    [
    f"Source: {doc.metadata['source']}\n"
    f"{doc.page_content}"
    for doc in relevant_docs
    ]
    )
    # Add context and question to prompt template
    messages = prompt.invoke(
    {
    "context": context,
    "question": question
    }
    )
    # Send completed prompt to Gemini
    response = llm.invoke(messages)
    # Return answer text
    return response.content

    เพื่อที่เราจะเขียนโค้ดสั้นลงในครั้งถัด ๆ ไป:

    Python
    # Test function
    answer = ask_policy_question("Who is eligible for health insurance?")
    print(answer)

    ผลลัพธ์:

    Full-time employees receive health insurance after completing probation. (Source: documents/benefits_policy.txt)

    💪 Summary

    ในบทความนี้ เราได้เรียนรู้การสร้าง RAG pipeline ด้วย LangChain ใน 5 ขั้นตอน:

    1. Load documents: โหลดเอกสารสำหรับ RAG pipeline
    2. Split text: แบ่ง text ในเอกสารเป็น chunk
    3. Embed and store chunks: แปลง chunk เป็น vector และเก็บลงใน database
    4. Create a retriever: สร้างตัวค้นหาเอกสารจาก vector database
    5. Generate a response: สร้างคำตอบจากเอกสาร

    😺 GitHub

    ดูตัวอย่าง code และเอกสารทั้งหมดได้ที่ GitHub


    📃 References

  • วิธีใช้ plot() เพื่อสร้างกราฟง่าย ๆ ในภาษา R — ตัวอย่างจาก trees dataset

    วิธีใช้ plot() เพื่อสร้างกราฟง่าย ๆ ในภาษา R — ตัวอย่างจาก trees dataset

    Data visualisation เป็นเครื่องมือที่สำคัญในการวิเคราะห์ข้อมูล เพราะช่วยให้เราทำความเข้าใจและสื่อสารเกี่ยวกับข้อมูลได้ง่าย

    plot() สำหรับสร้างกราฟอย่างง่ายในภาษา R

    ในบทความนี้ เราจะมาดูวิธีใช้ plot() เบื้องต้นกัน

    บทความนี้แบ่งเป็น 3 ส่วน:

    1. Syntax: วิธีเขียน plot()
    2. Basics: พื้นฐานการใช้ plot()
    3. Decoration: การตกแต่งกราฟ
    4. Add-on: การเพิ่มข้อมูลในกราฟ

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    🌲 Example Dataset: trees

    เราจะมาลองใช้ trees dataset ซึ่งมีข้อมูลต้น black cheery เป็นต้นอย่างกัน:

    # Load dataset
    data(trees)
    # View structure
    str(trees)

    ผลลัพธ์:

    'data.frame': 31 obs. of 3 variables:
    $ Girth : num 8.3 8.6 8.8 10.5 10.7 10.8 11 11 11.1 11.2 ...
    $ Height: num 70 65 63 72 81 83 66 75 80 75 ...
    $ Volume: num 10.3 10.3 10.2 16.4 18.8 19.7 15.6 18.2 22.6 19.9 ...

    💻 Syntax

    วิธีใช้ plot():

    plot(x, y, ...)
    func()
    • x = ข้อมูลแกน x
    • y = ข้อมูลแกน y
    • ... = argument อื่น ๆ สำหรับปรับแต่งกราฟ
    • func() = function อื่น ๆ สำหรับปรับแต่งกราฟ

    ☝️ Basics

    เราเริ่มใช้งาน plot() ได้ด้วย:

    1. x และ y: ใส่ข้อมูลในกราฟ
    2. type: เปลี่ยนประเภทกราฟ

    .

    🔢 x, y

    เราสร้างกราฟได้ง่าย ๆ ด้วยการเรียกใส่ข้อมูลแกน x และ y

    เช่น สร้างกราฟความสัมพันธ์ระหว่างขนาดลำต้น (Girth) และปริมาณ (Volume):

    # x, y
    plot(
    x = trees$Girth,
    y = trees$Volume
    )

    ผลลัพธ์:

    .

    📖 Plot Type

    ถ้าต้องการเปลี่ยนประเภทกราฟ ให้เราใช้ type:

    ArgumentPlot
    "p"Points
    "l"Line
    "b"Points + line
    "h"Vertical lines
    "n"Empty plot

    เช่น เปลี่ยน scatter plot เป็น line plot:

    # Plot type
    plot(
    x = trees$Girth,
    y = trees$Volume,
    type = "l"
    )

    ผลลัพธ์:


    🎁 Decoration

    เราตกแต่งกราฟได้ 2 แบบ:

    1. Text: ปรับแต่งข้อความ เช่น ชื่อกราฟ ชื่อแกน x, y
    2. Visual: ปรับแต่งหน้าตา เช่น สี รูปทรง ขนาด

    .

    🏷️ Text

    เราปรับแต่งข้อความได้ 3 ส่วน:

    1. xlab = ชื่อแกน x
    2. ylab = ชื่อแกน y
    3. main = ชื่อกราฟ

    เช่น:

    # Labels: xlab, ylab, main
    plot(
    x = trees$Girth,
    y = trees$Volume,
    xlab = "Girth (Inches)",
    ylab = "Volume (Cubic Feet)",
    main = "Tree Girth and Volume"
    )

    ผลลัพธ์:

    .

    🎨 Visual

    เราปรับแต่งหน้าตาได้ 3 ส่วน:

    1. col = สีข้อมูล
    2. pch = รูปทรง
    3. cex = ขนาดข้อมูล

    เช่น:

    # Colour, shape, and size
    plot(
    x = trees$Girth,
    y = trees$Volume,
    xlab = "Girth (Inches)",
    ylab = "Volume (Cubic Feet)",
    main = "Tree Girth and Volume",
    col = "darkgreen",
    pch = 5,
    cex = 1.5
    )

    ผลลัพธ์:


    🚀 Add-On

    เราสามารถเพิ่มข้อมูลลงในกราฟได้ด้วย function อื่น ๆ ในภาษา R

    เช่น abline() สำหรับเพิ่มเส้นตรง อย่างเส้น regression:

    # Regression line
    plot(
    x = trees$Girth,
    y = trees$Volume,
    xlab = "Girth (Inches)",
    ylab = "Volume (Cubic Feet)",
    main = "Tree Girth and Volume",
    col = "darkgreen",
    pch = 5,
    cex = 1.5
    )
    abline(
    lm(Volume ~ Girth, data = trees),
    col = "red",
    lwd = 2
    )

    ผลลัพธ์:


    💪 Summary

    ในบทความนี้ เราได้เรียนรู้วิธีใช้ plot() เพื่อสร้างกราฟอย่างง่ายในภาษา R:

    • x, y = ข้อมูลสำหรับแกน x และ y
    • type = เปลี่ยนรูปแบบการแสดงผลของกราฟ
    • xlab, ylab = ชื่อแกน x และ y
    • main = ชื่อกราฟ
    • col = สีของจุดหรือเส้นในกราฟ
    • pch = รูปทรงของจุดข้อมูล
    • cex = ขนาดของจุดข้อมูล
    • abline() = เพิ่มเส้นตรง เช่น เส้น regression

    😺 GitHub

    ดูตัวอย่าง code ทั้งหมดได้ที่ GitHub


    📃 References


    ✅ R Book for Psychologists: หนังสือภาษา R สำหรับนักจิตวิทยา

    📕 ขอฝากหนังสือเล่มแรกในชีวิตด้วยนะครับ 😆

    🙋 ใครที่กำลังเรียนจิตวิทยาหรือทำงานสายจิตวิทยา และเบื่อที่ต้องใช้ software ราคาแพงอย่าง SPSS และ Excel เพื่อทำข้อมูล

    💪 ผมขอแนะนำ R Book for Psychologists หนังสือสอนใช้ภาษา R เพื่อการวิเคราะห์ข้อมูลทางจิตวิทยา ที่เขียนมาเพื่อนักจิตวิทยาที่ไม่เคยมีประสบการณ์เขียน code มาก่อน

    ในหนังสือ เราจะปูพื้นฐานภาษา R และพาไปดูวิธีวิเคราะห์สถิติที่ใช้บ่อยกัน เช่น:

    • Correlation
    • t-tests
    • ANOVA
    • Reliability
    • Factor analysis

    🚀 เมื่ออ่านและทำตามตัวอย่างใน R Book for Psychologists ทุกคนจะไม่ต้องพึง SPSS และ Excel ในการทำงานอีกต่อไป และสามารถวิเคราะห์ข้อมูลด้วยตัวเองได้ด้วยความมั่นใจ

    แล้วทุกคนจะแปลกใจว่า ทำไมภาษา R ง่ายขนาดนี้ 🙂‍↕️

    👉 สนใจดูรายละเอียดหนังสือได้ที่ meb:

  • วิธีโหลดข้อมูล Google Sheets มาวิเคราะห์ใน Python บน Google Colab ใน 3 ขั้นตอน–ตัวอย่างจาก Harry Potter transaction dataset

    วิธีโหลดข้อมูล Google Sheets มาวิเคราะห์ใน Python บน Google Colab ใน 3 ขั้นตอน–ตัวอย่างจาก Harry Potter transaction dataset

    Google Sheets เป็นเครื่องมือเก็บข้อมูลที่ทุกคนสามารถเข้าถึงได้ฟรี และมักเป็นที่เก็บข้อมูลทั้งส่วนตัว (เช่น รายรับรายจ่าย) และธุรกิจ (เช่น ข้อมูลการขาย ข้อมูลลูกค้า)

    แม้ว่า Google Sheet จะวิเคราะห์ข้อมูลได้ แต่การวิเคราะห์จะมีประสิทธิภาพมากกว่า เมื่อเราใช้ programming language อย่าง Python เข้ามาช่วย

    นอกจากความรวดเร็วในการประมวลผล และรองรับข้อมูลปริมาณมาก Python ยังสามารถวิเคราะห์แบบอัตโนมัติได้ด้วย เพียงแค่เราเขียน code รอเอาไว้

    ในบทความนี้ เราจะมาดูวิธีการโหลดข้อมูลจาก Google Sheet เข้ามาวิเคราะห์ใน Python บน Google Colab กัน

    บทความนี้แบ่งเป็น 3 ส่วน:

    1. Load spreadsheet
    2. Load worksheet
    3. Load data

    สำหรับคนที่ต้องการทำตาม สามารถดูไฟล์ตัวอย่างได้ตาม link:

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    1️⃣ Step 1. Load Spreadsheet

    เริ่มแรก เราจะโหลด spreadsheet ที่ต้องการ ใน 2 ขั้นตอน:

    1. Authorise: ให้สิทธิ์การเข้าถึง Google Drive กับ Colab
    2. Open spreadsheet: เชื่อมต่อ Google Sheet ที่ต้องการ

    .

    ✅ 1.1 Authorise

    เราเปิดสิทธิ์การเข้าถึง Google Drive ให้กับ Colab ได้แบบนี้:

    # Grant Colab access to Google services
    # Import package
    from google.colab import auth
    # Enable access to Google services
    auth.authenticate_user()

    เมื่อกด “Run”, Google จะพาเราไปที่หน้า Sign In ให้เรากด “Continue”:

    จากนั้น ติ๊ก checkbox เพื่อให้สิทธิ์กับ Colab แล้วกด “Continue”

    หลังเปิดสิทธิ์ ให้เราสร้าง client เพื่อเข้าถึง Google Drive:

    # Connect to Google Drive
    # Import packages
    import gspread
    from google.auth import default
    # Get credentials and Google Cloud project ID
    creds, _ = default()
    # Create Google Sheet client
    gc = gspread.authorize(creds)

    Note:

    • default() จะคืนค่าให้ 2 อย่าง คือ credentials และ Google Cloud project ID
    • เราจะใช้เฉพาะ credentials
    • ส่วน Google Cloud project ID เราจะปล่อยทิ้งไป โดยเก็บไว้ใน _

    .

    📖 1.2 Open Spreadsheet

    หลังจากสร้าง client แล้ว เราจะเชื่อมต่อกับ spreadsheet ซึ่งเราจะต้องเอา ID ของ spreadsheet มาจาก URL ตามตัวอย่างในรูป:

    ให้เรา copy ID มาใช้แบบนี้:

    # Load spreadsheet
    # Define spreadsheet ID
    spreadsheet_id = "12MglU8pFc_7XAylqANyqm8aLQNwvL98fXObjHEjrRvQ"
    # Open spreadsheet
    spreadsheet = gc.open_by_key(spreadsheet_id)
    # Print spreadsheet title
    print(spreadsheet.title)

    ผลลัพธ์:

    Diagon Alley Artefacts

    ตอนนี้ เราก็โหลด spreadsheet สำเร็จแล้ว

    ตัวอย่าง spreadsheet:


    2️⃣ Step 2. Load Worksheet

    หลังจากโหลด Google Sheet แล้ว เราจะเชื่อมต่อกับ worksheet ที่ต้องการ ใน 2 ขั้นตอน:

    1. List: ดูรายชื่อ worksheet ทั้งหมดใน Google Sheet
    2. Select: เลือก worksheet

    .

    📋 2.1 List

    เราดูรายชื่อ worksheet ทั้งหมดได้แบบนี้:

    # List worksheets
    # Get all worksheet names
    worksheets = spreadsheet.worksheets()
    # Print them
    for ws in worksheets:
    print(ws.title)

    ผลลัพธ์:

    transactions
    Sheet2
    Sheet3

    .

    🫳 2.2 Select

    จากนั้น ให้เราโหลด worksheet ที่ต้องการ (เช่น transactions):

    # Select worksheet
    worksheet = spreadsheet.worksheet("transactions")

    ตอนนี้ เราก็เชื่อมต่อกับ worksheet สำเร็จแล้ว


    3️⃣ Step 3. Load Data

    สุดท้าย เราจะโหลดข้อมูลจาก worksheet ใน 3 ขั้นตอน:

    1. Read data: โหลดข้อมูลจาก worksheet
    2. Convert to DataFrame: เปลี่ยนข้อมูลให้เป็น DataFrame
    3. Analyse: วิเคราะห์ข้อมูลตามต้องการ

    .

    👓 3.1 Read Data

    เราจะโหลดข้อมูลจาก worksheet แบบนี้:

    # Get all data from worksheet
    data = worksheet.get_all_values()
    # Print result
    data

    โดยข้อมูลที่ได้จะเป็น list of lists (1 list = 1 row):

    .

    🐼 3.2 Convert to DataFrame

    เพื่อช่วยให้เราวิเคราะห์ข้อมูลได้ง่าย เราจะเปลี่ยนข้อมูลให้เป็น DataFrame ด้วย pandas:

    # Convert data to df
    # Import package
    import pandas as pd
    # Convert
    df = pd.DataFrame(
    data=data[1:],
    columns=data[0]
    )
    # Print result
    df

    ผลลัพธ์:

    .

    📈 3.3 Analyse

    จากนั้น เราสามารถวิเคราะห์ข้อมูลได้ตามต้องการ เช่น คำนวณยอดขายทั้งหมด:

    # Find total sales per category
    # Convert column types to numeric
    df["quantity"] = pd.to_numeric(df["quantity"], errors="coerce")
    df["unit_price"] = pd.to_numeric(df["unit_price"], errors="coerce")
    # Calculate total sales per row
    df["revenue"] = df["quantity"] * df["unit_price"]
    # Calculate sum sales
    total_sales = df["revenue"].sum()
    # Print result
    print(total_sales)

    ผลลัพธ์:

    11600.0

    Note:


    💪 Summary

    ในบทความนี้ เราดูวิธีโหลดข้อมูล Google Sheet เข้ามาใน Python บน Google Colab ใน 3 ขั้นตอน:

    Step 1. Load spreadsheet:

    CodeFor
    auth.authenticate_user()เปิดสิทธิ์เข้าถึง Google Drive
    default()รับ credentials
    gspread.authorize(creds)สร้าง client
    gc.open_by_key(spreadsheet_id)เชื่อมต่อ Google Sheet

    Step 2. Load worksheet:

    CodeFor
    spreadsheet.worksheets()ดูรายชื่อ worksheet ทั้งหมด
    spreadsheet.worksheet("worksheet_name")เลือก worksheet

    Step 3. Load data:

    CodeFor
    worksheet.get_all_values()โหลดข้อมูลใน worksheet
    pd.DataFrame(data=data[1:], columns=data[0])แปลงข้อมูลให้เป็น DataFrame

    📃 References

  • 3 วิธีโหลด flat file ในภาษา R: แนะนำการใช้ utils, readr, และ data.table packages เพื่อโหลดข้อมูลจาก flat files — ตัวอย่างการทำงานกับ Fast Food Joint Nutrition

    3 วิธีโหลด flat file ในภาษา R: แนะนำการใช้ utils, readr, และ data.table packages เพื่อโหลดข้อมูลจาก flat files — ตัวอย่างการทำงานกับ Fast Food Joint Nutrition

    ในบทความนี้ เราจะมาดูวิธีใช้ 3 packages สำหรับโหลด flat file ในภาษา R กัน

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    📁 Flat File คืออะไร?

    Flat file คือ ไฟล์ plain text ที่เก็บข้อมูลแบบตาราง (tabular data)

    Flat file ที่พบได้บ่อย เช่น:

    • CSV (comma-separated values)
    • TSV (tab-separated values)

    ตัวอย่าง flat file (CSV):

    Fast Food Joint Nutrition Values Dataset จาก Kaggle ซึ่งมีข้อมูลโภชนาการอาหารจาก restaurant chains อย่าง Pizza Hut, McDonald’s, และ Starbucks:

    Company,Category,Product,Per Serve Size,Energy (kCal),Carbohydrates (g),Protein (g),Fiber (g),Sugar (g),Total Fat (g),Saturated Fat (g),Trans Fat (g),Cholesterol (mg),Sodium (mg)
    Pizza Hut,All Meals,Corn n Cheese (Personal),143.5 g,432.6,65.64,17.91,3.85,0.0,10.93,5.14,0.16,16.19,499.72
    Pizza Hut,All Meals,Country Feast (Personal),178 g,407.6,67.11,16.73,7.19,0.0,8.03,3.24,0.11,66.8,818.0
    Pizza Hut,All Meals,Double Cheese (Personal),143 g,423.33,59.97,18.26,3.49,0.0,12.27,5.23,0.18,19.75,638.22
    Pizza Hut,All Meals,Double Paneer Supreme (Personal),174.5 g,474.03,52.86,20.07,3.79,0.0,20.26,9.25,0.33,71.72,1128.11
    Pizza Hut,All Meals,Farmer`s Pick (Personal),177 g,408.16,53.93,19.91,2.46,0.0,12.53,4.9,0.14,48.09,942.67

    📦 3 Packages

    ในภาษา R เรามี 3 packages สำหรับโหลด flat file ได้แก่:

    1. utils
    2. readr
    3. data.table

    เราไปดูวิธีใช้แต่ละ package กัน


    1️⃣ Package #1: utils

    utils เป็น package จาก base R ทำให้เราใช้งานได้โดยไม่ต้องโหลด package เพิ่มเติม

    utils มี 3 functions หลักสำหรับโหลด flat file ดังนี้:

    FunctionFor
    read.csv()โหลด CSV
    read.delim()โหลด TSV
    read.table()โหลด flat file ทั่วไป เช่น CSV, TSV, และอื่น ๆ

    ตัวอย่างการใช้งาน:

    โหลด Fast Food Joint Nutrition Values Dataset แบบ CSV:

    # Import with read.csv()
    nutrition.csv <- read.csv("Nutrition_Value_Dataset.csv")
    

    โหลด Fast Food Joint Nutrition Values Dataset แบบ TSV:

    # Import with read.delim()
    nutrition.delim <- read.delim("Nutrition_Value_Dataset.tsv")
    

    โหลด flat file อื่น ๆ เช่น flat file ซึ่งใช้ “/” แบ่งข้อมูล:

    nutrition.table <- read.table("Nutrition_Value_Dataset.txt",
                                  header = TRUE,
                                  sep = "/")
    

    ตัวอย่างผลลัพธ์:

    Company,Category,Product,Per Serve Size,Energy (kCal),Carbohydrates (g),Protein (g),Fiber (g),Sugar (g),Total Fat (g),Saturated Fat (g),Trans Fat (g),Cholesterol (mg),Sodium (mg)
    Pizza Hut,All Meals,Corn n Cheese (Personal),143.5 g,432.6,65.64,17.91,3.85,0.0,10.93,5.14,0.16,16.19,499.72
    Pizza Hut,All Meals,Country Feast (Personal),178 g,407.6,67.11,16.73,7.19,0.0,8.03,3.24,0.11,66.8,818.0
    Pizza Hut,All Meals,Double Cheese (Personal),143 g,423.33,59.97,18.26,3.49,0.0,12.27,5.23,0.18,19.75,638.22
    Pizza Hut,All Meals,Double Paneer Supreme (Personal),174.5 g,474.03,52.86,20.07,3.79,0.0,20.26,9.25,0.33,71.72,1128.11
    Pizza Hut,All Meals,Farmer`s Pick (Personal),177 g,408.16,53.93,19.91,2.46,0.0,12.53,4.9,0.14,48.09,942.67

    Note:

    read.csv() และ read.tsv() เป็น wrapper function ของ read.table() หรือ function ที่ทำให้เราใช้งาน read.table() ได้ง่ายขึ้น

    นั่นหมายความว่า ทุกครั้งที่เราเรียกใช้ read.csv() และ read.delim() เรากำลังเรียกใช้ read.table() แบบนี้:

    Wrapper Functionread.table()
    read.csv()read.table(file, header = TRUE, sep = ",")
    read.tsv()read.table(file, header = TRUE, sep = "\\t")

    2️⃣ Package #2: readr

    readr เป็น package ที่ทำงานคล้ายกับ utils แต่แทนที่โหลด flat file เป็น data frame, readr โหลดข้อมูลเป็น tibble ซึ่งเป็น data frame เว่อร์ชั่นที่มีประสิทธิภาพมากขึ้น

    readr มี 3 functions หลักสำหรับโหลด flat file ซึ่งเทียบได้กับ utils ดังนี้:

    utilsreadrFor
    read.csv()read_csv()โหลด CSV
    read.delim()read_tsv()โหลด TSV
    read.table()read_delim()โหลด flat file ทั่วไป เช่น CSV, TSV, และอื่น ๆ

    ตัวอย่างการใช้งาน:

    ก่อนเริ่มใช้งาน เราต้องติดตั้งและโหลด readr ก่อน:

    # Install
    install.packages("readr")
    
    # Load
    library(readr)
    

    จากนั้น เราสามารถเรียกใช้งาน functions ของ readr ได้เลย:

    โหลด Fast Food Joint Nutrition Values Dataset แบบ CSV:

    # Import with read_csv()
    nutrition_csv <- read_csv("Nutrition_Value_Dataset.csv")
    

    โหลด Fast Food Joint Nutrition Values Dataset แบบ TSV:

    # Import with read_tsv()
    nutrition_tsv <- read_tsv("Nutrition_Value_Dataset.tsv")
    

    โหลด flat file อื่น ๆ เช่น flat file ซึ่งใช้ “/” แบ่งข้อมูล:

    # Import with read_delim()
    nutrition_delim <- read_delim("Nutrition_Value_Dataset.txt",
                                  delim = "/")
    

    ตัวอย่างผลลัพธ์:

    # A tibble: 6 × 14
    Company Category Product `Per Serve Size` `Energy (kCal)` `Carbohydrates (g)` `Protein (g)` `Fiber (g)` `Sugar (g)` `Total Fat (g)` `Saturated Fat (g)`
    <chr> <chr> <chr> <chr> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
    1 Pizza Hut All Meals Corn n Chee… 143.5 g 433. 65.6 17.9 3.85 0 10.9 5.14
    2 Pizza Hut All Meals Country Fea… 178 g 408. 67.1 16.7 7.19 0 8.03 3.24
    3 Pizza Hut All Meals Double Chee… 143 g 423. 60.0 18.3 3.49 0 12.3 5.23
    4 Pizza Hut All Meals Double Pane… 174.5 g 474. 52.9 20.1 3.79 0 20.3 9.25
    5 Pizza Hut All Meals Farmer`s Pi… 177 g 408. 53.9 19.9 2.46 0 12.5 4.9
    6 Pizza Hut All Meals Margherita … 130.5 g 362. 50.7 15.9 4.08 0 10.6 3.86
    # ℹ 3 more variables: `Trans Fat (g)` <dbl>, `Cholesterol (mg)` <dbl>, `Sodium (mg)` <dbl>

    Note:

    เช่นเดียวกับ utils, read_csv() และ read_tsv() เป็น wrapper function ของ read_delim()


    3️⃣ Package #3: data.table

    สุดท้าย data.table เป็น data manipulation package ที่เน้นความเร็วในการประมวลผล

    data.table มี function สำหรับโหลด flat file ที่ใช้ง่ายและรวดเร็วกว่า read.table() และ read_delim() ได้แก่ fread() (ย่อมาจาก fast read)

    ข้อมูลที่โหลดด้วย fread() จะอยู่ในรูป data.table ซึ่งเป็นประเภท data frame ที่ทรงพลังกว่า

    ตัวอย่างการใช้งาน:

    เช่นเดียวกับ readr เราต้องติดตั้งและโหลด data.table ก่อนเริ่มใช้งาน:

    # Install
    install.packages("data.table")
    
    # Load
    library(data.table)
    

    จากนั้น เราสามารถเรียกใช้งาน fread() เพื่อโหลดไฟล์ได้:

    โหลด Fast Food Joint Nutrition Values Dataset แบบ CSV:

    # Import CSV with fread()
    nutrition_fread_csv <- fread("Nutrition_Value_Dataset.csv")
    

    โหลด Fast Food Joint Nutrition Values Dataset แบบ TSV:

    # Import TSV with fread()
    nutrition_fread_tsv <- fread("Nutrition_Value_Dataset.tsv")
    

    โหลด flat file อื่น ๆ เช่น flat file ซึ่งใช้ “/” แบ่งข้อมูล:

    # Import TXT with "/" separator with fread()
    nutrition_fread_txt <- fread("Nutrition_Value_Dataset.txt",
                                 sep = "/")
    

    ตัวอย่างผลลัพธ์:

         Company  Category                          Product Per Serve Size Energy (kCal) Carbohydrates (g) Protein (g) Fiber (g) Sugar (g) Total Fat (g) Saturated Fat (g) Trans Fat (g) Cholesterol (mg) Sodium (mg)
          <char>    <char>                           <char>         <char>         <num>             <num>       <num>     <num>     <num>         <num>             <num>         <num>            <num>       <num>
    1: Pizza Hut All Meals         Corn n Cheese (Personal)        143.5 g        432.60             65.64       17.91      3.85         0         10.93              5.14          0.16            16.19      499.72
    2: Pizza Hut All Meals         Country Feast (Personal)          178 g        407.60             67.11       16.73      7.19         0          8.03              3.24          0.11            66.80      818.00
    3: Pizza Hut All Meals         Double Cheese (Personal)          143 g        423.33             59.97       18.26      3.49         0         12.27              5.23          0.18            19.75      638.22
    4: Pizza Hut All Meals Double Paneer Supreme (Personal)        174.5 g        474.03             52.86       20.07      3.79         0         20.26              9.25          0.33            71.72     1128.11
    5: Pizza Hut All Meals         Farmer`s Pick (Personal)          177 g        408.16             53.93       19.91      2.46         0         12.53              4.90          0.14            48.09      942.67
    6: Pizza Hut All Meals            Margherita (Personal)        130.5 g        361.73             50.69       15.93      4.08         0         10.58              3.86          0.12            26.47      713.82

    💪 Summary

    ในบทความนี้ เราได้ทำความรู้จักกับ 3 packages สำหรับโหลด flat file ในภาษา R:

    Package #1. utils:

    • read.csv()
    • read.delim()
    • read.table()

    Package #2. readr:

    • read_csv()
    • read_tsv()
    • read_delim()

    Package 3. data.table:

    • fread()

    📚 Further Reading

    สำหรับคนที่ต้องการศึกษาเพิ่มเติม สามารถอ่านคู่มือการใช้ functions ในบทความนี้ได้ดังนี้:


    😺 GitHub

    ดู code ทั้งหมดในบทความนี้ได้ที่ GitHub:


    📃 References

  • httr2: 3 ขั้นตอนในการทำงานกับข้อมูลบนเว็บด้วยภาษา R — ตัวอย่างการทำงานกับ Fake Store API

    httr2: 3 ขั้นตอนในการทำงานกับข้อมูลบนเว็บด้วยภาษา R — ตัวอย่างการทำงานกับ Fake Store API

    httr2 (อ่านว่า “hitter 2”) เป็น API (application programming interface) package ในภาษา R เพื่อทำงานกับข้อมูลที่อยู่บนอินเทอร์เน็ต อย่างข้อมูลบนหน้าเว็บไซต์ต่าง ๆ เป็นต้น

    ในบทความนี้ เราจะมาลองดูวิธีใช้ httr2 ผ่านการทำงานกับ Fake Store API ซึ่งมีข้อมูลจำลองของร้านค้าออนไลน์กัน

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    🏪 Install & Load httr2

    ในการใช้งาน httr2 เราจะต้องไม่ลืมติดตั้งและโหลด package ก่อนแบบนี้:

    # Install httr2
    install.packages("httr2")
    
    # Library httr2
    library(httr2)
    

    💻 Working With API in 3 Steps

    การใช้งาน httr2 มีอยู่ 3 ขั้นตอน ได้แก่:

    1. Build request: สร้าง request ที่จะส่ง
    2. Send request: ส่ง request ไปยังปลายทาง
    3. Interact with response: ทำงานกับข้อมูลที่ได้รับ

    เราลองไปดูทั้ง 3 ขั้นตอนจากตัวอย่างการดึงข้อมูล products (GET) จาก Fake Store API กัน


    ✍️ Step 1. Build Request

    ในขั้นแรก เราจะสร้าง request ที่เราจะส่งให้กับ Fake Store API:

    1. กำหนด base URL ของ Fake Store API
    2. สร้าง request ด้วย request()
    3. เพิ่ม endpoint ใน URL ด้วย req_url_path_append()
    # Define base URL
    base_url <- "<https://fakestoreapi.com>"
    
    # Build a request
    get_req <- request(base_url) |>
      
      # Add endpoint
      req_url_path_append("products")
    

    ในขั้นนี้ request จะยังไม่ถูกส่งออกไป และเราสามารถทดสอบ request ได้ด้วย req_dry_run():

    # Dry run the request
    get_req |> req_dry_run()
    

    ผลลัพธ์:

    GET /products HTTP/1.1
    accept: */*
    accept-encoding: deflate, gzip
    host: fakestoreapi.com
    user-agent: httr2/1.1.2 r-curl/6.4.0 libcurl/8.14.1
    

    📨 Step 2. Send Request

    เมื่อเราพอใจกับผลทดสอบ เราสามารถส่ง request ออกไปได้ด้วย req_perform():

    # Perform the request
    get_resp <- get_req |> req_perform()
    

    เราสามารถเช็กสถานะของ response ได้ด้วย resp_status():

    # View response status
    get_resp |> resp_status()
    

    ผลลัพธ์:

    200
    

    ซึ่งแสดงให้เห็นว่า request ของเราส่ง response กลับมาได้สำเร็จ


    🧑‍💻 Step 3. Interact With Response

    ในขั้นสุดท้าย เราจะสำรวจ response ที่ได้กลับมากัน:

    1. Check content type: เช็กประเภทข้อมูล
    2. Get body: ดึงข้อมูลจาก response
    3. View data: ดูตัวอย่างข้อมูล

    .

    📋 Check Content Type

    เราสามารถเช็กประเภทข้อมูลใน response ได้ด้วย resp_content_type():

    # Check the response content type
    get_resp |> resp_content_type()
    

    ผลลัพธ์:

    "application/json"
    

    ซึ่งแสดงให้เห็นว่า สิ่งที่ได้รับกลับมาอยู่ในรูปแบบ JSON

    .

    📥 Get Body

    จากนั้น เราสามารถดึงข้อมูลจาก response ได้ด้วย resp_body_*() เช่น:

    • resp_body_html(): ดึงข้อมูลที่เป็น HTML
    • resp_body_xml(): ดึงข้อมูลที่เป็น XML
    • resp_body_json(): ดึงข้อมูลที่เป็น JSON

    อย่างในตัวอย่าง เราจะดึงข้อมูลด้วย resp_body_json() เพราะข้อมูลของเราเป็น JSON:

    # Extract the content
    products <- get_resp |> resp_body_json()
    

    .

    👀 View Data

    สุดท้าย เราสามารถดูตัวอย่างข้อมูลได้ด้วย head():

    # View the first entry
    head(products, n = 1)
    

    ผลลัพธ์:

    [[1]]
    [[1]]$id
    [1] 1
    
    [[1]]$title
    [1] "Fjallraven - Foldsack No. 1 Backpack, Fits 15 Laptops"
    
    [[1]]$price
    [1] 109.95
    
    [[1]]$description
    [1] "Your perfect pack for everyday use and walks in the forest. Stash your laptop (up to 15 inches) in the padded sleeve, your everyday"
    
    [[1]]$category
    [1] "men's clothing"
    
    [[1]]$image
    [1] "<https://fakestoreapi.com/img/81fPKd-2AYL._AC_SL1500_.jpg>"
    
    [[1]]$rating
    [[1]]$rating$rate
    [1] 3.9
    
    [[1]]$rating$count
    [1] 120
    

    📬 POST, PATCH, DELETE

    จากตัวอย่าง เราจะเห็นได้ว่า functions ของ httr2 แบ่งเป็น 2 กลุ่ม ได้แก่:

    1. req_*() ซึ่งใช้กับ request
    2. resp_*() ซึ่งใช้กับ response

    นอกจาก functions ที่เราได้เห็นก่อนหน้านี้ httr2 ยังมี functions อื่นที่ให้เรียกใช้งานได้ เช่น:

    • req_method(): เปลี่ยน method ของ request
    • req_body_json(): เปลี่ยน body ของ request

    ยกตัวอย่างเช่น เราต้องการเปลี่ยน method เป็น POST เพื่อสร้าง product ใหม่บนหน้าเว็บ เราสามารถใช้ req_method() และ req_body_json() ได้แบบนี้:

    # Build a request
    post_req <- request(base_url) |>
      
      # Add endpoint
      req_url_path_append("products") |>
      
      # Change method to POST
      req_method("POST") |>
      
      # Add body
      req_body_json(list(
        title = "Summer Sunglasses",
        price = 29.99,
        description = "One pair for all summers.",
        image = "<https://unsplash.com/photos/sunglasses-beside-a-purse-LJqRUWr9V0w>",
        category = "Accessory"
        ))
    
    

    หรือ PATCH เพื่ออัปเดตข้อมูล product:

    # Build a request
    patch_req <- request(base_url) |>
      
      # Add endpoint
      req_url_path_append("products/1001") |>
      
      # Change method to PATCH
      req_method("PATCH") |>
      
      # Add body
      req_body_json(list(
        price = 59.99,
        description = "Limited edition: One pair for all summers."
      ))
    

    หรือ DELETE เพื่อลบ product ออก:

    # Build a request
    delete_req <- request(base_url) |>
      
      # Add endpoint
      req_url_path_append("products/1001") |>
      
      # Change method to DELETE
      req_method("DELETE")
    

    เป็นต้น

    สำหรับคนที่สนใจ สามารถศึกษา functions อื่น ๆ ของ httr2 เพิ่มเติมได้ที่ บทความ official ของ httr2


    😺 GitHub

    ดูตัวอย่าง code ทั้งหมดได้ที่ GitHub


    📃 References


    ✅ R Book for Psychologists: หนังสือภาษา R สำหรับนักจิตวิทยา

    📕 ขอฝากหนังสือเล่มแรกในชีวิตด้วยนะครับ 😆

    🙋 ใครที่กำลังเรียนจิตวิทยาหรือทำงานสายจิตวิทยา และเบื่อที่ต้องใช้ software ราคาแพงอย่าง SPSS และ Excel เพื่อทำข้อมูล

    💪 ผมขอแนะนำ R Book for Psychologists หนังสือสอนใช้ภาษา R เพื่อการวิเคราะห์ข้อมูลทางจิตวิทยา ที่เขียนมาเพื่อนักจิตวิทยาที่ไม่เคยมีประสบการณ์เขียน code มาก่อน

    ในหนังสือ เราจะปูพื้นฐานภาษา R และพาไปดูวิธีวิเคราะห์สถิติที่ใช้บ่อยกัน เช่น:

    • Correlation
    • t-tests
    • ANOVA
    • Reliability
    • Factor analysis

    🚀 เมื่ออ่านและทำตามตัวอย่างใน R Book for Psychologists ทุกคนจะไม่ต้องพึง SPSS และ Excel ในการทำงานอีกต่อไป และสามารถวิเคราะห์ข้อมูลด้วยตัวเองได้ด้วยความมั่นใจ

    แล้วทุกคนจะแปลกใจว่า ทำไมภาษา R ง่ายขนาดนี้ 🙂‍↕️

    👉 สนใจดูรายละเอียดหนังสือได้ที่ meb:

  • วิธีใช้ LangChain เชื่อมต่อ LLM ด้วย Python ใน 5 ขั้นตอน

    วิธีใช้ LangChain เชื่อมต่อ LLM ด้วย Python ใน 5 ขั้นตอน

    langchain เป็น framework สำหรับสร้างแอปพลิเคชั่นที่ใช้ large language model (LLM) ที่ช่วยลดความยุ่งยากการเรียกใช้งาน API โดยตรง

    langchain มีข้อดี 3 อย่าง:

    1. Modular: ใช้งานง่าย ด้วยการเขียนเป็นส่วน ๆ หรือ module (เหมือนเลโก้)
    2. Use case: รองรับการใช้งานหลายหลาก เพราะสามารถประกอบ module เข้าด้วยกันได้หลายแบบ (ต่อเลโก้ได้หลายแบบ)
    3. Integration: ใช้งานร่วมเครื่องมือได้กับหลากหลาย เช่น OpenAI, Hugging Face, databricks

    ในบทความนี้ เรามาดูวิธีใช้ langchain เพื่อทำงานกับ LLM อย่างง่ายกัน

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    ☀️ Overview

    การใช้งาน langchain มีอยู่ 5 ขั้นตอน ได้แก่:

    1. Set LLM: เลือก LLM ที่ต้องการ
    2. Set prompt: สร้าง prompt สำหรับคุยกับ LLM
    3. Set output structure: กำหนดหน้าตา output ที่ต้องการ
    4. Chain: เชื่อม LLM และ prompt เข้าด้วยกัน เพื่อสร้าง pipeline ในการเรียกใช้ LLM
    5. Run: เรียกใช้งาน LLM

    เราไปดูการใช้งาน ผ่านการสร้าง chatbot ตอบคำถามเกี่ยวกับ mental model กัน


    🤖 Step 1. Set LLM

    langchain รองรับการใช้งาน LLM หลายเจ้า เช่น:

    ในตัวอย่าง เราจะเลือกใช้ Gemini โดยเริ่มจากโหลด module สำหรับเชื่อมกับ Gemini:

    Python
    # Import package
    from langchain_google_genai import ChatGoogleGenerativeAI

    แล้วสร้าง LLM instance ขึ้นมา:

    Python
    # Create model instance
    llm = ChatGoogleGenerativeAI(
    model="gemini-2.5-flash",
    temperature=0.5,
    api_key="YOUR_API_KEY"
    )
    • model: ชื่อ LLM ที่เราต้องการใช้งาน
    • temperature: ระดับความสุ่มของคำตอบจาก LLM (ค่ายิ่งสูง คำตอบยิ่งมีความหลากหลาย ส่วนยิ่งค่าน้อย คำตอบจะยิ่งมีความคล้ายคลึงกัน)
    • api_key: API key สำหรับใช้งาน LLM (ดูวิธีการสร้าง Gemini API key ฟรี)

    💬 Step 2. Set Prompt

    ในขั้นที่ 2 เราจะสร้าง prompt สำหรับคุยกับ LLM กัน:

    1. โหลด module
    2. กำหนด prompt

    ขั้นย่อยที่ 1. โหลด module สำหรับสร้าง prompt:

    Python
    # Import package
    from langchain_core.prompts import ChatPromptTemplate

    ขั้นย่อยที่ 2. กำหนด prompt โดยแยกระหว่าง:

    1. System prompt: บทบาทและสไตล์การตอบคำถามของ LLM (เช่น ผู้เชี่ยวชาญด้าน mental model)
    2. User prompt: คำถามที่จะส่งให้ LLM (เช่น บอกให้อธิบาย mental model ที่ต้องการ)

    ตัวอย่าง system และ user prompts:

    Python
    # Define system prompt
    system_prompt = """
    You are an expert curator of mental models across science, philosophy, and applied reasoning.
    Your task is to explain mental models clearly and accurately using a fixed schema.
    If the origin of a model is unclear or debated, state that explicitly.
    Do not invent historical sources. Be concise and concrete.
    """
    # Define user prompt
    user_prompt = "Explain the following mental model: {model_query}"

    จากนั้น ประกอบ prompts เข้าด้วยกัน:

    Python
    # Create prompt template
    prompts = ChatPromptTemplate.from_messages(
    [
    # System prompt
    ("system", system_prompt.strip()),
    # User prompt
    ("human", user_prompt)
    ]
    )

    เราสามารถดูตัวอย่าง prompt ได้ด้วย .format_messages():

    Python
    # Inspect prompt template
    prompts.format_messages(model_query="Pareto Principle")

    ผลลัพธ์:

    [SystemMessage(content='You are an expert curator of mental models across science, philosophy, and applied reasoning.\\n\\nYour task is to explain mental models clearly and accurately using a fixed schema.\\n\\nIf the origin of a model is unclear or debated, state that explicitly.\\n\\nDo not invent historical sources. Be concise and concrete.', additional_kwargs={}, response_metadata={}),
    HumanMessage(content='Explain the following mental model: Pareto Princinple', additional_kwargs={}, response_metadata={})]

    📦 Step 3. Set Output Structure

    ในขั้นที่ 3 เราจะกำหนดหน้าตา output ที่เราต้องการ

    เช่น ถ้าเราต้องการให้คืนค่า JSON แบบนี้:

    {
    "model_name": "",
    "origin": "",
    "description": "",
    "example": "",
    "tags": []
    }

    เรากำหนดได้โดยใช้ pydantic และ typing packages แบบนี้:

    Python
    # Import packages
    from pydantic import BaseModel, Field
    from typing import List, Literal
    # Define output structure
    class MentalModel(BaseModel):
    # Mental model name
    model_name: str = Field(description="The commonly accepted name of the mental model")
    # Source/origin
    origin: str = Field(
    description="Where the model comes from (person, book, field, or cultural origin)"
    )
    # Brief description
    description: str = Field(
    description="A brief explanation of what the mental model is and why it matters"
    )
    # Example
    example: str = Field(
    description="A concrete real-world example illustrating the mental model"
    )
    # Tags
    tags: List[str] = Field(
    description="Short tags such as decision-making, systems thinking, learning, philosophy"
    )

    Note: ดูวิธีใช้ Pydantic

    หลังกำหนดหน้าตา output แล้ว ให้ใส่เข้าไปใน LLM instance แบบนี้:

    Python
    # Add output structure to LLM
    llm_with_structured_output = llm.with_structured_output(MentalModel)

    ⛓️‍💥 Step 4. Chain

    ในขั้นที่ 4 ให้เราสร้าง chain โดยเชื่อม LLM instance เข้ากับ prompts ด้วย pipe operator (|):

    Python
    # Build chain
    chain = prompts | llm_with_structured_output

    Note: ให้มองว่า | เป็นลูกศรชี้ทางขวา (prompt → llm)


    🏃 Step 5. Run

    ในขั้นสุดท้าย เราจะเรียกใช้งาน chain ซึ่งทำได้ 2 แบบ:

    1. Single run: เรียกใช้ครั้งเดียว
    2. Batch run: เรียกใช้หลายครั้งพร้อมกัน

    .

    ☝️ Single Run

    เราเรียกใช้งานครั้งเดียวด้วย .invoke()

    ในตัวอย่าง เราจะถามเกี่ยวกับ “compound interest” กัน:

    Python
    # Run query
    result = chain.invoke({"model_query": "Compound Interest"})

    แสดงผลลัพธ์ใน console:

    Python
    # Import package
    import json
    # Load result
    result_dict = result.model_dump()
    # Print
    print(json.dumps(result_dict, indent=4))

    ผลลัพธ์:

    {
    "model_name": "Compound Interest",
    "origin": "Finance, Mathematics; concept dates back to ancient times, formalized in the Renaissance.",
    "description": "Compound interest is the interest on a loan or deposit calculated based on both the initial principal and the accumulated interest from previous periods. It is often called 'interest on interest' and leads to exponential growth over time, making it a powerful force in finance for both wealth creation and debt accumulation.",
    "example": "If you invest $1,000 at an annual interest rate of 5% compounded annually, after the first year you'll have $1,050. In the second year, the 5% interest is calculated on $1,050, not just the original $1,000, leading to a balance of $1,102.50. This snowball effect accelerates over decades, significantly increasing the total return compared to simple interest.",
    "tags": [
    "Finance",
    "Economics",
    "Wealth Building",
    "Decision-making",
    "Long-term thinking"
    ]
    }

    .

    🎳 Batch Run

    สำหรับการรันหลายครั้งพร้อมกัน เราจะใช้ .batch() แบบนี้:

    Python
    # Create list of mental models
    mental_model_queries = [
    "First Principles Thinking",
    "Occam's Razor",
    "Confirmation Bias"
    ]
    # Create batch inputs
    batch_inputs = [{"model_query": query} for query in mental_model_queries]
    # Run queries
    results = chain.batch(batch_inputs)
    # Instantiate collector
    query_collector = [result.model_dump() for result in results]

    แสดงผลลัพธ์ใน console:

    Python
    # Instantiate counter
    i = 1
    # Loop through elements in collector
    for result in query_collector:
    # Print result
    print(f"👉 Query {i}:")
    print(json.dumps(result, indent=4))
    print("\\n")
    # Add 1 to counter
    i += 1

    ผลลัพธ์:

    👉 Query 1:
    {
    "model_name": "First Principles Thinking",
    "origin": "Often attributed to Aristotle; popularized in modern business by Elon Musk.",
    "description": "First Principles Thinking involves breaking down complex problems into their most basic, fundamental truths or 'first principles,' rather than reasoning by analogy or conventional wisdom. It matters because it allows for innovative solutions by challenging assumptions and building new knowledge from the ground up.",
    "example": "Instead of accepting the high cost of batteries for electric cars, Elon Musk famously broke down a battery into its constituent raw materials (cobalt, nickel, lithium, etc.) to understand their actual cost, then sought ways to procure and assemble them more efficiently, leading to significant cost reductions and innovation.",
    "tags": [
    "Problem-solving",
    "Innovation",
    "Critical Thinking",
    "Decision-making"
    ]
    }
    👉 Query 2:
    {
    "model_name": "Occam's Razor",
    "origin": "William of Ockham (14th-century philosopher and theologian)",
    "description": "Occam's Razor is a problem-solving principle stating that among competing hypotheses that explain an event or phenomenon equally well, the simplest solution is most likely the correct one. It advocates for parsimony, suggesting that one should not multiply entities beyond necessity, thereby favoring theories with fewer assumptions.",
    "example": "If you hear hoofbeats outside, it is more likely to be horses than zebras, assuming you are in a location where horses are common and zebras are not. The 'horse' explanation is simpler and requires fewer extraordinary assumptions.",
    "tags": [
    "Philosophy",
    "Decision-making",
    "Problem-solving",
    "Critical thinking",
    "Science"
    ]
    }
    👉 Query 3:
    {
    "model_name": "Confirmation Bias",
    "origin": "Psychology; early concepts traced to Francis Bacon's Novum Organum (1620)",
    "description": "Confirmation bias is the tendency to search for, interpret, favor, and recall information in a way that confirms one's pre-existing beliefs or hypotheses. It matters because it can lead to flawed reasoning, poor decision-making, and resistance to new or contradictory evidence, hindering objective analysis.",
    "example": "A person who believes a certain stock will perform well might selectively read news articles and analyst reports that support this positive outlook, while ignoring or downplaying any negative news or warnings about the company.",
    "tags": [
    "cognitive bias",
    "decision-making",
    "psychology",
    "critical thinking"
    ]
    }

    💪 Summary

    เราจะได้เห็นได้ว่า langchain เป็น package ที่ใช้ทำงานกับ LLM ได้อย่างง่าย ๆ ใน 5 ขั้นตอน:

    Set LLM: เลือก model
    Set prompt: กำหนด system และ user prompt
    Set output: กำหนด output structure
    Chain: สร้าง pipeline
    Run: เรียกใช้งาน (single & batch)

    🫵 Your Turn

    อ่านบทความจบแล้ว ลองมาใช้ langchain กันนะครับ:


    📄 References

  • วิธีใช้ jsonlite เพื่อทำงานกับ JSON ในภาษา R: fromJSON(), toJSON(), read_json(), และ write_json() — ตัวอย่างการทำงานกับข้อมูลขนม

    วิธีใช้ jsonlite เพื่อทำงานกับ JSON ในภาษา R: fromJSON(), toJSON(), read_json(), และ write_json() — ตัวอย่างการทำงานกับข้อมูลขนม

    ในบทความนี้ เราจะไปดูวิธีการใช้ 4 functions จาก jsonlite package สำหรับทำงานกับ JSON (JavaScript Object Notation) ในภาษา R กัน:

    1. fromJSON()
    2. toJSON()
    3. read_json()
    4. write_json()

    ถ้าพร้อมแล้ว ไปเริ่มกันเลย



    🤔 What Is JSON?

    JSON เป็นโครงสร้างข้อมูลที่พบได้บ่อยในระบบคอมพิวเตอร์และแอปพลิเคชันต่าง ๆ เพราะเป็นรูปแบบข้อมูลที่อ่านได้ง่ายทั้งคนและคอมพิวเตอร์

    ตัวอย่าง JSON ที่เก็บข้อมูลขนม:

    [
      {
        "snack_name": "Corn Chips",
        "brand": "Nibble & Dip",
        "price_usd": 2.99,
        "is_vegan": true
      },
      {
        "snack_name": "Pita Chips",
        "brand": "DipMates",
        "price_usd": 4.25,
        "is_vegan": false
      },
      {
        "snack_name": "Tortilla Chips",
        "brand": "Casa Crunch",
        "price_usd": 3.49,
        "is_vegan": true
      }
    ]
    

    Note: อ่านเพิ่มเติมเกี่ยวกับ JSON ได้ที่ What is JSON?


    📦 What Is jsonlite?

    jsonlite เป็น package ขนาดเบาสำหรับทำงานกับ JSON ในภาษา R และมี 4 functions หลักให้เรียกใช้งาน ได้แก่:

    1. fromJSON(): โหลด JSON string (character ที่มีข้อมูลแบบ JSON) เป็น R object (เช่น data frame)
    2. toJSON(): เปลี่ยน R object เป็น JSON string
    3. read_json(): โหลดไฟล์ JSON เป็น R object
    4. write_json(): เปลี่ยน R object เป็นไฟล์ JSON

    เราไปดูวิธีใช้ jsonlite และ 4 functions นี้กัน


    🏁 Getting Started

    ก่อนเริ่มใช้งาน jsonlite เราจะต้องทำ 2 อย่าง ได้แก่:

    1. ติดตั้ง package ด้วย install.packages() (ทำครั้งแรกครั้งเดียว)
    2. โหลด package ด้วย library() (ทำทุกครั้งที่เปิด session ใหม่)
    # Install jsonlite
    install.packages("jsonlite")
    
    # Load jsonlite
    library(jsonlite)
    

    ⬇️ Function 1. fromJSON()

    fromJSON() ใช้เปลี่ยน JSON ที่เป็นอยู่ใน character (JSON string) ให้เป็น R object เช่น list และ data frame

    เช่น เราสามารถเปลี่ยน JSON string แบบนี้:

    # Create a JSON string
    snacks_json_string <- '
    [
      {
        "snack_name": "Corn Chips",
        "brand": "Nibble & Dip",
        "price_usd": 2.99,
        "is_vegan": true
      },
      {
        "snack_name": "Pita Chips",
        "brand": "DipMates",
        "price_usd": 4.25,
        "is_vegan": false
      },
      {
        "snack_name": "Tortilla Chips",
        "brand": "Casa Crunch",
        "price_usd": 3.49,
        "is_vegan": true
      }
    ]
    '
    
    

    ให้เป็น R object ได้แบบนี้:

    # Convert to R object
    snacks_r_obj <- fromJSON(snacks_json_string)
    
    # View the df
    snacks_r_obj
    

    ผลลัพธ์:

          snack_name        brand price_usd is_vegan
    1     Corn Chips Nibble & Dip      2.99     TRUE
    2     Pita Chips     DipMates      4.25    FALSE
    3 Tortilla Chips  Casa Crunch      3.49     TRUE
    

    Note: fromJSON() จะเลือกประเภท R object ให้โดยอัตโนมัติ เช่น ถ้า JSON มีโครงสร้างคล้าย data frame (มีข้อมูลซ้ำ ๆ ที่ดูเหมือน rows และ columns) fromJSON() จะเปลี่ยน JSON string ให้เป็น data frame


    ⬆️ Function 2. toJSON()

    toJSON() ใช้เปลี่ยน R object ให้เป็น JSON string

    เช่น เปลี่ยน data frame นี้:

    # Create a data frame
    snacks_df <- data.frame(
      snack_name = c("Seaweed Thins", "Chickpea Puffs", "BBQ Potato Crisps"),
      brand      = c("OceanBite", "LegumeLab", "Spud & Spark"),
      price_usd  = c(2.45, 3.35, 3.10),
      is_vegan   = c(TRUE, TRUE, FALSE),
      stringsAsFactors = FALSE
    )
    

    ให้เป็น JSON string:

    # Convert to JSON string
    snacks_json_string <- toJSON(snacks_df)
    
    # View the JSON string
    snacks_json_string
    

    ผลลัพธ์:

    [{"snack_name":"Seaweed Thins","brand":"OceanBite","price_usd":2.45,"is_vegan":true},{"snack_name":"Chickpea Puffs","brand":"LegumeLab","price_usd":3.35,"is_vegan":true},{"snack_name":"BBQ Potato Crisps","brand":"Spud & Spark","price_usd":3.1,"is_vegan":false}]
    

    สังเกตว่า ผลลัพธ์ที่ได้มาอ่านยาก เพราะข้อมูลอยู่ในบรรทัดเดียวกันหมด

    ทั้งนี้ เราเปลี่ยนให้ผลลัพธ์อ่านง่ายขึ้นได้ โดยใช้ pretty argument แบบนี้:

    # Convert to JSON string (pretty)
    snacks_json_string_pretty <- toJSON(snacks_df,
    pretty = TRUE)
    # View the JSON string (pretty)
    snacks_json_string_pretty

    ผลลัพธ์:

    [
      {
        "snack_name": "Seaweed Thins",
        "brand": "OceanBite",
        "price_usd": 2.45,
        "is_vegan": true
      },
      {
        "snack_name": "Chickpea Puffs",
        "brand": "LegumeLab",
        "price_usd": 3.35,
        "is_vegan": true
      },
      {
        "snack_name": "BBQ Potato Crisps",
        "brand": "Spud & Spark",
        "price_usd": 3.1,
        "is_vegan": false
      }
    ]
    

    จะเห็นว่า ตอนนี้ JSON string อ่านง่ายกว่าก่อนหน้านี้มาก


    📖 Function 3. read_json()

    read_json() ใช้โหลดไฟล์ JSON เข้ามาใน R

    เช่น เรามีไฟล์ชื่อ snacks.json ที่มีข้อมูลแบบนี้:

    [
      {
        "snack_name": "Plantain Chips",
        "brand": "TropiBite",
        "price_usd": 3.15,
        "is_vegan": true
      },
      {
        "snack_name": "Rice Crackers",
        "brand": "ZenMunch",
        "price_usd": 2.25,
        "is_vegan": true
      },
      {
        "snack_name": "Pretzel Sticks",
        "brand": "Twist & Dip",
        "price_usd": 3.75,
        "is_vegan": true
      }
    ]
    

    เราสามารถโหลดเข้ามาใน R ด้วย read_json() ได้แบบนี้:

    # Read the JSON file
    snacks_from_json_file <- read_json("snacks.json")
    
    # View the result
    snacks_from_json_file
    

    ผลลัพธ์:

    [[1]]
    [[1]]$snack_name
    [1] "Plantain Chips"
    
    [[1]]$brand
    [1] "TropiBite"
    
    [[1]]$price_usd
    [1] 3.15
    
    [[1]]$is_vegan
    [1] TRUE
    
    [[2]]
    [[2]]$snack_name
    [1] "Rice Crackers"
    
    [[2]]$brand
    [1] "ZenMunch"
    
    [[2]]$price_usd
    [1] 2.25
    
    [[2]]$is_vegan
    [1] TRUE
    
    [[3]]
    [[3]]$snack_name
    [1] "Pretzel Sticks"
    
    [[3]]$brand
    [1] "Twist & Dip"
    
    [[3]]$price_usd
    [1] 3.75
    
    [[3]]$is_vegan
    [1] TRUE
    

    ทั้งนี้ read_json() มี simplifyVector argument ที่ช่วยโหลดข้อมูลที่เหมือน data frame ให้เป็น data frame (แทน list) ได้แบบนี้:

    # Read the JSON file (simplified)
    snacks_from_json_file_simplified <- read_json("snacks.json",
                                                  simplifyVector = TRUE)
    
    # View the result (simplified)
    snacks_from_json_file_simplified
    

    ผลลัพธ์:

          snack_name       brand price_usd is_vegan
    1 Plantain Chips   TropiBite      3.15     TRUE
    2  Rice Crackers    ZenMunch      2.25     TRUE
    3 Pretzel Sticks Twist & Dip      3.75     TRUE
    

    ✍️ Function 4. write_json()

    write_json() ใช้เปลี่ยน R object ให้เป็นไฟล์ JSON

    เช่น เปลี่ยน data frame นี้:

    # Create a list
    snacks_df <- data.frame(
      snack_name = c("Cassava Chips", "Lentil Crisps", "Cheese Puffs"),
      brand      = c("RootRush", "Pulse & Crunch", "CheezyPop"),
      price_usd  = c(2.85, 2.65, 3.99),
      is_vegan   = c(TRUE, TRUE, FALSE),
      stringsAsFactors = FALSE
    )
    

    ให้เป็นไฟล์ JSON แบบนี้:

    # Write to JSON
    write_json(snacks_df,
               "snacks_df.json")
    

    ผลลัพธ์:

    [{"snack_name":"Cassava Chips","brand":"RootRush","price_usd":2.85,"is_vegan":true},{"snack_name":"Lentil Crisps","brand":"Pulse & Crunch","price_usd":2.65,"is_vegan":true},{"snack_name":"Cheese Puffs","brand":"CheezyPop","price_usd":3.99,"is_vegan":false}]
    

    เช่นเดียวกับ toJSON(), write_json() มี pretty argument ที่ทำให้ผลลัพธ์อ่านง่ายขึ้นได้:

    # Write to JSON (pretty)
    write_json(snacks_df,
               "snacks_df_pretty.json", 
               pretty = TRUE)
    

    ผลลัพธ์:

    [
      {
        "snack_name": "Cassava Chips",
        "brand": "RootRush",
        "price_usd": 2.85,
        "is_vegan": true
      },
      {
        "snack_name": "Lentil Crisps",
        "brand": "Pulse & Crunch",
        "price_usd": 2.65,
        "is_vegan": true
      },
      {
        "snack_name": "Cheese Puffs",
        "brand": "CheezyPop",
        "price_usd": 3.99,
        "is_vegan": false
      }
    ]
    

    💪 Summary

    ในบทความนี้ เราได้ไปทำความรู้จักกับ 4 functions จาก jsonlite ซึ่งเป็น package สำหรับทำงานกับ JSON ในภาษา R:

    1. fromJSON(): JSON string → R object
    2. toJSON(): R object → JSON string
    3. read_json(): ไฟล์ JSON → R object
    4. write_json(): R object → JSON

    😺 GitHub

    ดูตัวอย่าง code และไฟล์ JSON ทั้งหมดในบทความนี้ได้ที่ GitHub


    📃 References