ในยุคที่ AI เข้ามามีบทบาทสำคัญในการศึกษา การสร้างระบบเรียนรู้แบบปรับตัว (Adaptive Learning System) ที่ใช้ Knowledge Graph เพื่อแนะนำเส้นทางการเรียนเฉพาะบุคคล กลายเป็นทักษะที่นักพัฒนาต้องมี บทความนี้จะพาคุณสร้างระบบสมบูรณ์ตั้งแต่ต้นจนจบ

เริ่มต้นด้วยข้อผิดพลาดจริงที่เจอบ่อย

ตอนเริ่มพัฒนาระบบแรก ผมเจอข้อผิดพลาดนี้ตอนเรียก HolySheep API:

ConnectionError: HTTPSConnectionPool(host='api.holysheep.ai', port=443): 
Max retries exceeded with url: /v1/chat/completions (Caused by 
NewConnectionError('<urllib3.connection.HTTPSConnection object at 
0x7f8a2b1c4d60>: Failed to establish a new connection: [Errno 110] 
Connection timed out'))

เกิดจาก: timeout สำหรับ API request สั้นเกินไป

หลังจากแก้ไขปัญหานี้และปัญหาอื่นๆ อีกหลายข้อ ผมได้ระบบที่ทำงานได้อย่างราบรื่น มาเริ่มกันเลย

สถาปัตยกรรมระบบ Knowledge Graph

Knowledge Graph เป็นโครงสร้างข้อมูลที่แสดงความสัมพันธ์ระหว่างแนวคิดต่างๆ ในรูปแบบกราฟ เหมาะสำหรับการสร้างเส้นทางการเรียนที่เชื่อมโยงความรู้กัน

โครงสร้างข้อมูล Node และ Edge

import networkx as nx
from typing import Dict, List, Set, Optional
from dataclasses import dataclass, field
from enum import Enum

class NodeType(Enum):
    """ประเภทของโหนดใน Knowledge Graph"""
    CONCEPT = "concept"           # แนวคิดหลัก
    TOPIC = "topic"               # หัวข้อย่อย
    SKILL = "skill"               # ทักษะเฉพาะ
    PREREQUISITE = "prerequisite" # ความรู้พื้นฐานที่ต้องมี
    ASSESSMENT = "assessment"     # แบบทดสอบ

class Difficulty(Enum):
    """ระดับความยาก"""
    BEGINNER = 1
    ELEMENTARY = 2
    INTERMEDIATE = 3
    ADVANCED = 4
    EXPERT = 5

@dataclass
class KnowledgeNode:
    """โหนดความรู้ในกราฟ"""
    node_id: str
    name: str
    description: str
    node_type: NodeType
    difficulty: Difficulty
    estimated_minutes: int
    resources: List[str] = field(default_factory=list)
    tags: Set[str] = field(default_factory=set)
    learning_objectives: List[str] = field(default_factory=list)

@dataclass
class LearningEdge:
    """ความสัมพันธ์ระหว่างโหนด"""
    source: str
    target: str
    relationship: str  # "prerequisite", "reinforces", "leads_to"
    weight: float = 1.0  # ความแน่นแค่ว์ของความสัมพันธ์ (0-1)

class KnowledgeGraph:
    """กราฟความรู้หลัก"""
    
    def __init__(self):
        self.graph = nx.DiGraph()
        self.nodes: Dict[str, KnowledgeNode] = {}
        
    def add_node(self, node: KnowledgeNode) -> None:
        """เพิ่มโหนดเข้ากราฟ"""
        self.graph.add_node(node.node_id)
        self.nodes[node.node_id] = node
        self.graph.nodes[node.node_id]['data'] = node
        
    def add_edge(self, edge: LearningEdge) -> None:
        """เพิ่มความสัมพันธ์ระหว่างโหนด"""
        self.graph.add_edge(
            edge.source, 
            edge.target, 
            relationship=edge.relationship,
            weight=edge.weight
        )


ตัวอย่าง: สร้าง Knowledge Graph สำหรับ Python Programming

kg = KnowledgeGraph()


เพิ่มโหนดความรู้

python_basics = KnowledgeNode(
    node_id="py001",
    name="พื้นฐาน Python",
    description="ตัวแปร ชนิดข้อมูล การดำเนินการ",
    node_type=NodeType.CONCEPT,
    difficulty=Difficulty.BEGINNER,
    estimated_minutes=120,
    tags={"python", "programming", "basics"}
)

functions = KnowledgeNode(
    node_id="py002",
    name="ฟังก์ชัน",
    description="การสร้างและใช้งานฟังก์ชัน",
    node_type=NodeType.TOPIC,
    difficulty=Difficulty.ELEMENTARY,
    estimated_minutes=90,
    tags={"python", "functions", "modular"}
)

oop = KnowledgeNode(
    node_id="py003",
    name="Object-Oriented Programming",
    description="Class, Object, Inheritance, Polymorphism",
    node_type=NodeType.TOPIC,
    difficulty=Difficulty.INTERMEDIATE,
    estimated_minutes=180,
    tags={"python", "oop", "classes"}
)

kg.add_node(python_basics)
kg.add_node(functions)
kg.add_node(oop)


เพิ่มความสัมพันธ์

kg.add_edge(LearningEdge("py001", "py002", "prerequisite", 0.95))
kg.add_edge(LearningEdge("py002", "py003", "prerequisite", 0.90))

print(f"สร้าง Knowledge Graph สำเร็จ: {len(kg.nodes)} โหนด")

ระบบแนะนำเส้นทางการเรียน (Learning Path Recommender)

หลังจากมี Knowledge Graph แล้ว ต่อไปจะสร้างระบบที่แนะนำเส้นทางการเรียนเฉพาะบุคคลโดยใช้ HolySheep AI

import requests
import json
from typing import List, Dict, Tuple
import time

class HolySheepAPIClient:
    """Client สำหรับ HolySheep AI API"""
    
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json"
        }
        
    def analyze_knowledge_gaps(
        self, 
        user_id: str,
        current_level: str,
        target_level: str,
        weak_areas: List[str]
    ) -> Dict:
        """
        ใช้ AI วิเคราะห์ช่องว่างความรู้ของผู้เรียน
        
        ตัวอย่าง:
        - ปัจจุบัน: รู้พื้นฐาน Python
        - เป้าหมาย: สร้าง Web Application
        - จุดอ่อน: OOP, Database
        """
        prompt = f"""วิเคราะห์ช่องว่างความรู้สำหรับผู้เรียน:
        
ระดับปัจจุบัน: {current_level}
ระดับเป้าหมาย: {target_level}
จุดที่ต้องปรับปรุง: {', '.join(weak_areas)}

ให้ผลลัพธ์เป็น JSON ที่มี:
1. priority_topics: หัวข้อที่ต้องเรียนก่อน (เรียงตามความสำคัญ)
2. estimated_hours: จำนวนชั่วโมงที่ต้องการ
3. learning_order: ลำดับการเรียนที่แนะนำ
"""
        
        payload = {
            "model": "gpt-4.1",
            "messages": [
                {"role": "system", "content": "คุณเป็นผู้เชี่ยวชาญด้านการศึกษา AI"},
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.7,
            "max_tokens": 1000
        }
        
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=self.headers,
            json=payload,
            timeout=30  # ตั้ง timeout ให้เหมาะสม
        )
        
        if response.status_code == 401:
            raise AuthenticationError("API Key ไม่ถูกต้อง กรุณาตรวจสอบ")
        elif response.status_code == 429:
            raise RateLimitError("เกินโควต้า กรุณารอแล้วลองใหม่")
        elif response.status_code != 200:
            raise APIError(f"เกิดข้อผิดพลาด: {response.status_code}")
            
        return response.json()
    
    def generate_personalized_content(
        self,
        topic: str,
        user_level: str,
        learning_style: str = "visual"
    ) -> str:
        """
        สร้างเนื้อหาการเรียนเฉพาะบุคคล
        
        ตัวอย่างการใช้:
        - topic: "Python OOP"
        - user_level: "intermediate"
        - learning_style: "hands-on"
        """
        prompt = f"""สร้างเนื้อหาการเรียนสำหรับหัวข้อ: {topic}
ระดับผู้เรียน: {user_level}
รูปแบบการเรียน: {learning_style}

รวม:
- คำอธิบายแนวคิด
- ตัวอย่างโค้ดที่ใช้งานได้จริง
- แบบฝึกหัดที่ปฏิบัติได้
- สรุปประเด็นสำคัญ
"""
        
        payload = {
            "model": "gpt-4.1",
            "messages": [
                {"role": "system", "content": "คุณเป็นครูสอน Python ที่เชี่ยวชาญ"},
                {"role": "user", "content": prompt}
            ],
            "temperature": 0.8,
            "max_tokens": 2000
        }
        
        response = requests.post(
            f"{self.base_url}/chat/completions",
            headers=self.headers,
            json=payload,
            timeout=45
        )
        response.raise_for_status()
        
        result = response.json()
        return result['choices'][0]['message']['content']


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

API_KEY = "YOUR_HOLYSHEEP_API_KEY"  # เปลี่ยนเป็น API Key จริง
client = HolySheepAPIClient(API_KEY)

try:
    # วิเคราะห์ช่องว่างความรู้
    gaps = client.analyze_knowledge_gaps(
        user_id="user_12345",
        current_level="Python ระดับเริ่มต้น",
        target_level="สร้าง Web Application ด้วย Python",
        weak_areas=["OOP", "Database", "API"]
    )
    print("ผลการวิเคราะห์:", json.dumps(gaps, indent=2, ensure_ascii=False))
    
except AuthenticationError as e:
    print(f"ข้อผิดพลาดการยืนยันตัวตน: {e}")
except RateLimitError as e:
    print(f"เกินโควต้า: {e}")
except APIError as e:
    print(f"ข้อผิดพลาด API: {e}")

ระบบติดตามความก้าวหน้าแบบ Real-time

การสร้างระบบที่ปรับเส้นทางการเรียนแบบ Real-time ต้องอาศัยการติดตามความก้าวหน้าและปรับเปลี่ยนตามผลการเรียน

from dataclasses import dataclass
from typing import Optional, Dict
from datetime import datetime
import json

@dataclass
class LearnerProfile:
    """โปรไฟล์ผู้เรียน"""
    learner_id: str
    name: str
    current_knowledge: Dict[str, float]  # topic_id -> mastery_level (0-1)
    completed_nodes: set
    time_spent: Dict[str, int]  # node_id -> นาที
    quiz_scores: Dict[str, float]  # quiz_id -> score (0-100)
    preferred_learning_style: str
    available_hours_per_week: int

@dataclass
class LearningPath:
    """เส้นทางการเรียนที่แนะนำ"""
    path_id: str
    learner_id: str
    nodes: list  # ลำดับโหนดที่ต้องเรียน
    estimated_total_hours: float
    created_at: datetime
    adjustments_made: int = 0

class AdaptiveLearningEngine:
    """เครื่องมือปรับเปลี่ยนการเรียนแบบอัจฉริยะ"""
    
    def __init__(self, knowledge_graph: KnowledgeGraph, api_client: HolySheepAPIClient):
        self.kg = knowledge_graph
        self.api_client = api_client
        self.learners: Dict[str, LearnerProfile] = {}
        self.paths: Dict[str, LearningPath] = {}
        
    def create_learning_path(
        self,
        learner_id: str,
        start_topic: str,
        target_topic: str,
        learner_profile: LearnerProfile
    ) -> LearningPath:
        """
        สร้างเส้นทางการเรียนเฉพาะบุคคล
        
        ขั้นตอน:
        1. หาเส้นทางจาก start ถึง target ในกราฟ
        2. กรองเฉพาะโหนดที่ยังไม่ได้เรียน
        3. ใช้ AI ปรับลำดับตามสไตล์การเรียน
        """
        # หาเส้นทางสั้นที่สุด
        try:
            shortest_path = nx.shortest_path(
                self.kg.graph, 
                start_topic, 
                target_topic
            )
        except nx.NetworkXNoPath:
            # ไม่มีเส้นทางตรง ต้องหาเส้นทางอ้อม
            shortest_path = self._find_alternative_path(start_topic, target_topic)
        
        # กรองโหนดที่ยังไม่เชี่ยวชาญ
        learning_nodes = self._filter_unguided_nodes(
            shortest_path, 
            learner_profile
        )
        
        # คำนวณเวลาโดยประมาณ
        total_minutes = sum(
            self.kg.nodes[node_id].estimated_minutes 
            for node_id in learning_nodes
        )
        
        # สร้าง Learning Path
        path = LearningPath(
            path_id=f"path_{learner_id}_{int(time.time())}",
            learner_id=learner_id,
            nodes=learning_nodes,
            estimated_total_hours=total_minutes / 60,
            created_at=datetime.now()
        )
        
        self.paths[learner_id] = path
        return path
    
    def _filter_unguided_nodes(
        self, 
        path: list, 
        profile: LearnerProfile
    ) -> list:
        """กรองเฉพาะโหนดที่ต้องเรียน"""
        nodes_to_learn = []
        
        for node_id in path:
            if node_id not in profile.completed_nodes:
                mastery = profile.current_knowledge.get(node_id, 0)
                if mastery < 0.7:  # ถ้าความเชี่ยวชาญต่ำกว่า 70%
                    nodes_to_learn.append(node_id)
                    
        return nodes_to_learn
    
    def _find_alternative_path(self, start: str, target: str) -> list:
        """หาเส้นทางอ้อมเมื่อไม่มีเส้นทางตรง"""
        # ใช้ BFS เพื่อหาเส้นทางที่สั้นที่สุด
        all_paths = list(nx.all_simple_paths(self.kg.graph, start, target))
        
        if not all_paths:
            return [start]  # คืนค่าเริ่มต้นถ้าไม่มีเส้นทางเลย
        
        # เลือกเส้นทางที่สั้น

แหล่งข้อมูลที่เกี่ยวข้อง
บทความที่เกี่ยวข้อง