Upload 14 files

Rekomendasi Materi Belajar/edtech/backend/models/recommenders/collaborative/collab_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4aef73c6272415cb11002c1ff5c96f65587498acaa7c86ad4f7167d1d73fe48
+size 6080

Rekomendasi Materi Belajar/edtech/backend/models/recommenders/content_based/content_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63d1a2f5acb72fa4e6c3825586d578da46d850c31d82883ef50f618789722977
+size 5211833

Rekomendasi Materi Belajar/edtech/backend/models/recommenders/hybrid/hybrid_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d173427052471e467df306ab61013e0599cfb0a80ff3805e464f9b7a25166933
+size 32

Rekomendasi Materi Belajar/edtech/backend/src/app.py

@@ -0,0 +1,193 @@
+# backend/src/app.py/recommendation
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from contextlib import asynccontextmanager
+import joblib
+import pandas as pd
+from typing import List, Optional
+import uvicorn
+from pathlib import Path
+from recommendation.collaborative import CollaborativeFiltering
+from recommendation.content_based import ContentBasedRecommender
+from recommendation.hybrid import HybridRecommender
+
+# ===== KONFIGURASI SERVER =====
+HOST = "0.0.0.0"  #untuk deploy hugging face
+PORT = 8025
+RELOAD = True  # Set False di production
+WORKERS = 1
+
+# ===== LIFESPAN MANAGEMENT =====
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Mengelola siklus hidup aplikasi dan inisialisasi model"""
+    print("Memuat model rekomendasi...")
+    try:
+        # Load semua model
+        app.state.collab_model = CollaborativeFiltering.load_model(COLLAB_MODEL_PATH)
+        app.state.content_model = ContentBasedRecommender.load_model(CONTENT_MODEL_PATH)
+        app.state.hybrid_model = HybridRecommender.load_model(
+            collab_path=COLLAB_MODEL_PATH,
+            content_path=CONTENT_MODEL_PATH,
+            hybrid_path=HYBRID_MODEL_PATH
+        )
+        print("✅ Model berhasil dimuat!")
+    except Exception as e:
+        print(f"❌ Gagal memuat model: {str(e)}")
+        raise HTTPException(status_code=500, detail="Gagal memuat model")
+    yield
+    print("🛑 Server dimatikan")
+
+# ===== INISIALISASI APLIKASI =====
+app = FastAPI(
+    title="Sistem Rekomendasi Materi Pembelajaran",
+    description="API untuk memberikan rekomendasi materi pembelajaran personalisasi",
+    version="1.0.2",
+    lifespan=lifespan,
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# ===== KONFIGURASI CORS =====
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3025"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# ===== PATH MODEL =====
+MODEL_DIR = Path("models/recommenders")
+COLLAB_MODEL_PATH = MODEL_DIR / "collaborative/collab_model.joblib"
+CONTENT_MODEL_PATH = MODEL_DIR / "content_based/content_model.joblib"
+HYBRID_MODEL_PATH = MODEL_DIR / "hybrid/hybrid_model.joblib"
+
+# ===== SCHEMA REQUEST/RESPONSE =====
+class RecommendationRequest(BaseModel):
+    user_id: str
+    user_history: List[str]
+    n_recommendations: int = 5
+    algorithm: str = "hybrid"
+
+class MaterialRecommendationRequest(BaseModel):
+    material_id: str
+    n_recommendations: int = 5
+
+class RecommendationItem(BaseModel):
+    material_id: str
+    score: float
+    confidence: float = 0.0  # Tambahan field baru
+
+class RecommendationResponse(BaseModel):
+    success: bool
+    recommendations: List[RecommendationItem]
+    algorithm: str
+    message: Optional[str] = None
+
+# ===== ENDPOINT API =====
+@app.get("/")
+async def root():
+    return {
+        "message": "Selamat datang di API Rekomendasi Pembelajaran",
+        "version": app.version,
+        "docs": f"http://{HOST}:{PORT}/docs"
+    }
+
+@app.post("/recommend", response_model=RecommendationResponse)
+async def get_recommendations(request: RecommendationRequest):
+    try:
+        # Validasi input
+        if not request.user_id:
+            raise HTTPException(
+                status_code=400,
+                detail="User ID diperlukan",
+                headers={"Content-Type": "application/json"}
+            )
+            
+        if not request.user_history and request.algorithm != "collaborative":
+            raise HTTPException(
+                status_code=400,
+                detail="User history diperlukan untuk algoritma ini",
+                headers={"Content-Type": "application/json"}
+            )
+        # Format response yang lebih konsisten
+        recommendations = []
+        if request.algorithm == "hybrid":
+            recommendations = app.state.hybrid_model.recommend_for_user(
+                user_id=request.user_id,
+                user_history=request.user_history or [],  # Handle None
+                df=pd.DataFrame(),
+                n_recommendations=request.n_recommendations
+            )
+        elif request.algorithm == "collaborative":
+            recommendations = app.state.collab_model.recommend_for_user(
+                user_id=request.user_id
+            )[:request.n_recommendations]
+        else:
+            recommendations = app.state.content_model.recommend_for_user(
+                user_id=request.user_id,
+                user_history=request.user_history or [],  # Handle None
+                df=pd.DataFrame()
+            )[:request.n_recommendations]
+
+        # Pastikan format response konsisten
+        recommendation_items = [
+            {
+                "material_id": item[0], 
+                "score": float(item[1]),
+                "confidence": min(float(item[1]) * 100, 99.9)
+            }
+            for item in recommendations
+        ]
+        
+        return {
+            "success": True,
+            "recommendations": recommendation_items,
+            "algorithm": request.algorithm,
+            "message": "Rekomendasi berhasil dibuat"
+        }
+        
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=str(e),
+            headers={"Content-Type": "application/json"}
+        )
+
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy" if all([
+            hasattr(app.state, "collab_model"),
+            hasattr(app.state, "content_model"),
+            hasattr(app.state, "hybrid_model")
+        ]) else "unhealthy",
+        "details": {
+            "collaborative_loaded": hasattr(app.state, "collab_model"),
+            "content_loaded": hasattr(app.state, "content_model"),
+            "hybrid_loaded": hasattr(app.state, "hybrid_model")
+        }
+    }
+
+# ===== KONFIGURASI SERVER =====
+def run_server():
+    """Menjalankan server Uvicorn"""
+    config = uvicorn.Config(
+        app,
+        host=HOST,
+        port=PORT,
+        reload=RELOAD,
+        workers=WORKERS,
+        log_level="info"
+    )
+    server = uvicorn.Server(config)
+    
+    print(f"🚀 Server berjalan di http://{HOST}:{PORT}")
+    print(f"📚 Dokumentasi API tersedia di http://{HOST}:{PORT}/docs")
+    
+    server.run()
+
+if __name__ == "__main__":
+    run_server()

Rekomendasi Materi Belajar/edtech/backend/src/models/recommenders/collaborative/collab_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4aef73c6272415cb11002c1ff5c96f65587498acaa7c86ad4f7167d1d73fe48
+size 6080

Rekomendasi Materi Belajar/edtech/backend/src/models/recommenders/content_based/content_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:63d1a2f5acb72fa4e6c3825586d578da46d850c31d82883ef50f618789722977
+size 5211833

Rekomendasi Materi Belajar/edtech/backend/src/models/recommenders/hybrid/hybrid_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d173427052471e467df306ab61013e0599cfb0a80ff3805e464f9b7a25166933
+size 32

Rekomendasi Materi Belajar/edtech/backend/src/recommendation/collaborative.py

@@ -0,0 +1,144 @@
+# backend/src/recommendation/collaborative.py
+import numpy as np
+import pandas as pd
+from scipy.sparse.linalg import svds
+from sklearn.metrics.pairwise import cosine_similarity
+import joblib
+from pathlib import Path
+from scipy.sparse import csr_matrix
+
+class CollaborativeFiltering:
+    def __init__(self, n_factors=50, n_recommendations=5):
+        self.n_factors = n_factors
+        self.n_recommendations = n_recommendations
+        self.user_item_matrix = None
+        self.user_factors = None
+        self.item_factors = None
+        self.user_ids = None
+        self.item_ids = None
+    
+    def fit(self, user_item_matrix):
+        self.user_item_matrix = user_item_matrix
+        self.user_ids = user_item_matrix.index
+        self.item_ids = user_item_matrix.columns
+        
+        # Normalisasi dengan subtract mean
+        user_means = user_item_matrix.mean(axis=1)
+        normalized_matrix = user_item_matrix.sub(user_means, axis=0).fillna(0)
+        
+        # Convert the matrix to sparse format (CSR format)
+        sparse_matrix = csr_matrix(normalized_matrix.values)
+        
+        # Tentukan nilai k secara dinamis untuk dataset kecil
+        min_dim = min(sparse_matrix.shape)
+        k = min(self.n_factors, min_dim - 1) if min_dim > 1 else 1
+        
+        # Jika dimensi terlalu kecil, gunakan similarity dasar
+        if k < 1:
+            print("Matriks terlalu kecil, menggunakan similarity dasar")
+            self.similarity_matrix = cosine_similarity(normalized_matrix.T)
+            return
+        
+        print(f"Menentukan k = {k} berdasarkan dimensi matriks: {sparse_matrix.shape}")
+        
+        try:
+            # Melakukan SVD dengan penanganan khusus untuk matriks kecil
+            U, sigma, Vt = svds(sparse_matrix, k=k)
+            
+            # Mengubah sigma menjadi matriks diagonal
+            sigma = np.diag(sigma)
+            
+            # Membuat user dan item factors
+            self.user_factors = U
+            self.item_factors = sigma @ Vt
+        except Exception as e:
+            print(f"Error dalam SVD: {str(e)} - menggunakan similarity dasar")
+            self.similarity_matrix = cosine_similarity(normalized_matrix.T)
+
+    def recommend_for_user(self, user_id, user_item_matrix=None):
+        if user_item_matrix is not None:
+            self.user_item_matrix = user_item_matrix
+        
+        # Handle jika user_id tidak ada di data training
+        if user_id not in self.user_ids:
+            print(f"User ID {user_id} tidak ditemukan di model")
+            # Fallback: return popular items
+            item_counts = (self.user_item_matrix > 0).sum()
+            top_items = item_counts.sort_values(ascending=False).head(self.n_recommendations).index
+            return [(item, 0.5) for item in top_items]
+        
+        try:
+            # Jika menggunakan similarity dasar
+            if hasattr(self, 'similarity_matrix'):
+                user_idx = np.where(self.user_ids == user_id)[0][0]
+                user_ratings = self.user_item_matrix.iloc[user_idx].values
+                unseen_mask = user_ratings == 0
+                item_scores = self.similarity_matrix.dot(user_ratings)
+                item_scores[~unseen_mask] = -np.inf  # Filter yang sudah dilihat
+                top_indices = np.argsort(-item_scores)[:self.n_recommendations]
+                return [(self.item_ids[i], item_scores[i]) for i in top_indices if item_scores[i] > 0]
+            
+            # Jika menggunakan SVD
+            user_idx = np.where(self.user_ids == user_id)[0][0]
+            user_ratings = self.user_factors[user_idx, :] @ self.item_factors
+            
+            # Dapatkan item yang belum dilihat user
+            known_items = self.user_item_matrix.loc[user_id]
+            unseen_items_idx = np.where(known_items == 0)[0]
+            
+            # Jika tidak ada item yang belum dilihat, kembalikan popular items
+            if len(unseen_items_idx) == 0:
+                item_counts = (self.user_item_matrix > 0).sum()
+                top_items = item_counts.sort_values(ascending=False).head(self.n_recommendations).index
+                return [(item, 0.5) for item in top_items]
+            
+            # Urutkan item yang belum dilihat berdasarkan prediksi rating
+            unseen_ratings = user_ratings[unseen_items_idx]
+            recommended_idx = np.argsort(-unseen_ratings)[:self.n_recommendations]
+            
+            # Buat rekomendasi
+            recommendations = []
+            for idx in recommended_idx:
+                item_id = self.item_ids[unseen_items_idx[idx]]
+                score = unseen_ratings[idx]
+                recommendations.append((item_id, score))
+            
+            return recommendations
+        except Exception as e:
+            print(f"Error dalam rekomendasi untuk user {user_id}: {str(e)}")
+            # Fallback: return popular items
+            item_counts = (self.user_item_matrix > 0).sum()
+            top_items = item_counts.sort_values(ascending=False).head(self.n_recommendations).index
+            return [(item, 0.5) for item in top_items]
+        
+    def save_model(self, save_path='models/recommenders/collaborative'):
+        """
+        Menyimpan model yang sudah dilatih
+        """
+        Path(save_path).mkdir(parents=True, exist_ok=True)
+        
+        model_data = {
+            'user_factors': self.user_factors,
+            'item_factors': self.item_factors,
+            'user_ids': self.user_ids,
+            'item_ids': self.item_ids,
+            'n_factors': self.n_factors
+        }
+        
+        joblib.dump(model_data, f'{save_path}/collab_model.joblib')
+        print("Model Collaborative Filtering berhasil disimpan!")
+    
+    @classmethod
+    def load_model(cls, load_path='models/recommenders/collaborative/collab_model.joblib'):
+        """
+        Memuat model yang sudah disimpan
+        """
+        model_data = joblib.load(load_path)
+        
+        model = cls(n_factors=model_data['n_factors'])
+        model.user_factors = model_data['user_factors']
+        model.item_factors = model_data['item_factors']
+        model.user_ids = model_data['user_ids']
+        model.item_ids = model_data['item_ids']
+        
+        return model

Rekomendasi Materi Belajar/edtech/backend/src/recommendation/content_based.py

@@ -0,0 +1,198 @@
+# backend/src/recommendation/content_based.py
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import linear_kernel
+import joblib
+from pathlib import Path
+import numpy as np
+import pandas as pd
+
+class ContentBasedRecommender:
+    def __init__(self, n_recommendations=5):
+        self.n_recommendations = n_recommendations
+        self.tfidf_vectorizer = None
+        self.tfidf_matrix = None
+        self.material_features = None
+        self.material_ids = None
+    
+    def fit(self, df):
+        # Gabungkan fitur teks materi dengan lebih banyak fitur untuk dataset kecil
+        df['material_features'] = (
+            df['related_materials'].fillna('') + " " + 
+            df['subject_English'].astype(str) + " " +
+            df['subject_History'].astype(str) + " " +
+            df['subject_Mathematics'].astype(str) + " " +
+            df['subject_Science'].astype(str) + " " +
+            df['material_type_encoded'].astype(str) + " " +
+            df['preferensi_materi'].fillna('').astype(str) + " " +
+            df['performance_label_encoded'].astype(str)
+        )
+
+        # Simpan mapping material_id untuk referensi
+        self.material_ids = df['material_type_encoded'].unique()
+        
+        # Inisialisasi TF-IDF Vectorizer dengan parameter untuk data kecil
+        self.tfidf_vectorizer = TfidfVectorizer(
+            stop_words='english',
+            min_df=1,  # Term muncul di minimal 1 dokumen
+            max_df=0.95,  # Term muncul di maksimal 95% dokumen
+            max_features=1000  # Batasi jumlah fitur
+        )
+        
+        try:
+            self.tfidf_matrix = self.tfidf_vectorizer.fit_transform(df['material_features'])
+            self.cosine_sim = linear_kernel(self.tfidf_matrix, self.tfidf_matrix)
+        except Exception as e:
+            print(f"Error dalam TF-IDF: {str(e)}")
+            # Buat matriks identitas sebagai fallback
+            n = len(df)
+            self.cosine_sim = np.eye(n)
+        
+        # Buat mapping antara index dan material_id dengan fallback
+        self.indices = pd.Series(df.index, index=df['material_type_encoded']).drop_duplicates()
+
+    def recommend_for_user(self, user_id, user_history, df):
+        """Rekomendasi untuk user berdasarkan riwayat"""
+        if not user_history or len(user_history) < 1:
+            # Return default recommendations with adjusted scores
+            top_materials = df['material_type_encoded'].value_counts().head(self.n_recommendations).index.tolist()
+            return [(mat, 0.5 * df[df['material_type_encoded'] == mat]['engagement_score'].mean()) 
+                    for mat in top_materials]
+        
+        try:
+            # Dapatkan materi yang pernah diakses user
+            user_materials = df[df['material_type_encoded'].isin(user_history)]
+            if len(user_materials) == 0:
+                return []
+                
+            # Hitung profil user dengan normalisasi
+            user_profile = self._create_user_profile(user_history, df)
+            if user_profile is None:
+                return []
+            
+            # Hitung similarity dengan normalisasi
+            user_profile = user_profile.reshape(1, -1)
+            cosine_sim = linear_kernel(user_profile, self.tfidf_matrix)
+            cosine_sim = (cosine_sim - cosine_sim.min()) / (cosine_sim.max() - cosine_sim.min() + 1e-10)
+            
+            # Gabungkan dengan engagement score
+            material_scores = {}
+            for idx, score in enumerate(cosine_sim[0]):
+                material_id = df.iloc[idx]['material_type_encoded']
+                if material_id not in user_history:
+                    engagement = df[df['material_type_encoded'] == material_id]['engagement_score'].mean()
+                    material_scores[material_id] = 0.7 * score + 0.3 * (engagement / 5.0)  # Normalisasi
+            
+            # Urutkan dan kembalikan rekomendasi
+            recommendations = sorted(material_scores.items(), key=lambda x: x[1], reverse=True)
+            return recommendations[:self.n_recommendations]
+            
+        except Exception as e:
+            print(f"Error generating recommendations for user {user_id}: {str(e)}")
+            return []
+        
+    def recommend_for_material(self, material_id):
+        """
+        Memberikan rekomendasi berdasarkan similarity konten
+        
+        Parameters:
+        - material_id: ID materi yang akan dicari similaritasnya
+        
+        Returns:
+        - recommendations: List rekomendasi material beserta similarity scores
+        """
+        try:
+            idx = self.indices[material_id]
+        except KeyError:
+            print(f"Material ID {material_id} tidak ditemukan")
+            return []
+        
+        # Dapatkan similarity scores untuk semua materi
+        sim_scores = list(enumerate(self.cosine_sim[idx]))
+        
+        # Urutkan berdasarkan similarity score
+        sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)
+        
+        # Ambil n_recommendations teratas (tidak termasuk diri sendiri)
+        sim_scores = sim_scores[1:self.n_recommendations+1]
+        
+        # Dapatkan material indices
+        material_indices = [i[0] for i in sim_scores]
+        
+        # Buat rekomendasi
+        recommendations = []
+        for i, (idx, score) in enumerate(sim_scores):
+            rec_material_id = self.material_ids[material_indices[i]]
+            recommendations.append((rec_material_id, score))
+        
+        return recommendations
+    
+    
+    def _create_user_profile(self, user_history, df):
+        """
+        Membuat profil user berdasarkan riwayat materi yang diakses
+    
+        Parameters:
+        - user_history: List material_id yang pernah diakses user
+        - df: DataFrame lengkap untuk mendapatkan fitur materi
+    
+        Returns:
+        - user_profile: Vektor TF-IDF yang merepresentasikan preferensi user
+        """
+        # Dapatkan index materi yang pernah diakses user
+        history_indices = []
+        for material_id in user_history:
+            try:
+                idx = self.indices[material_id]  # Dapatkan indeks berdasarkan material_id
+                history_indices.append(idx)
+            except KeyError:
+                continue
+
+        # Pastikan history_indices tidak kosong dan memiliki bentuk yang benar
+        if not history_indices:
+            return None  # Jika tidak ada materi yang bisa diakses, return None
+
+        # Filter untuk memastikan semua indeks adalah integer dan tidak memiliki nilai yang tidak diinginkan
+        history_indices = [idx for idx in history_indices if isinstance(idx, int)]
+
+        # Pastikan history_indices adalah array numpy yang valid
+        if len(history_indices) > 0:
+            history_indices = np.array(history_indices)
+        
+            # Hitung mean hanya jika ada history
+            user_profile = self.tfidf_matrix[history_indices].mean(axis=0)
+            return user_profile.A1  # Convert to dense array
+        return None
+    
+    def save_model(self, save_path='models/recommenders/content_based'):
+        """
+        Menyimpan model yang sudah dilatih
+        """
+        Path(save_path).mkdir(parents=True, exist_ok=True)
+        
+        model_data = {
+            'tfidf_vectorizer': self.tfidf_vectorizer,
+            'tfidf_matrix': self.tfidf_matrix,
+            'cosine_sim': self.cosine_sim,
+            'indices': self.indices,
+            'material_ids': self.material_ids,
+            'n_recommendations': self.n_recommendations
+        }
+        
+        joblib.dump(model_data, f'{save_path}/content_model.joblib')
+        print("Model Content-Based Filtering berhasil disimpan!")
+    
+    @classmethod
+    def load_model(cls, load_path='models/recommenders/content_based/content_model.joblib'):
+        """
+        Memuat model yang sudah disimpan
+        """
+        model_data = joblib.load(load_path)
+        
+        model = cls(n_recommendations=model_data['n_recommendations'])
+        model.tfidf_vectorizer = model_data['tfidf_vectorizer']
+        model.tfidf_matrix = model_data['tfidf_matrix']
+        model.cosine_sim = model_data['cosine_sim']
+        model.indices = model_data['indices']
+        model.material_ids = model_data['material_ids']
+        
+        return model

Rekomendasi Materi Belajar/edtech/backend/src/recommendation/data_splitter.py

@@ -0,0 +1,117 @@
+# backend/src/recommendation/data_splitter.py
+import pandas as pd
+from sklearn.model_selection import train_test_split
+import joblib
+from pathlib import Path
+
+class DataSplitter:
+    def __init__(self, test_size=0.2, random_state=42):
+        self.test_size = test_size
+        self.random_state = random_state
+    
+    def split_data(self, df):
+        """
+        Membagi data menjadi train dan test set untuk rekomendasi
+        
+        Parameters:
+        - df: DataFrame yang sudah diproses
+        
+        Returns:
+        - train_data: Data untuk training
+        - test_data: Data untuk testing
+        - user_item_matrix: Matriks interaksi user-item
+        """
+        # Cek kolom yang ada di data
+        print("Kolom-kolom dalam data:", df.columns)  # Menambahkan pengecekan kolom
+        
+        # Pastikan data sudah diacak
+        df = df.sample(frac=1, random_state=self.random_state).reset_index(drop=True)
+        
+        # Membagi data secara stratifikasi berdasarkan student_id
+        train_data, test_data = train_test_split(
+            df,
+            test_size=self.test_size,
+            random_state=self.random_state,
+            stratify=df['student_id']
+        )
+        
+        # Membuat user-item matrix untuk collaborative filtering
+        user_item_matrix = self._create_user_item_matrix(df)
+        
+        return train_data, test_data, user_item_matrix
+    
+    def _create_user_item_matrix(self, df):
+        # 1. Hitung composite engagement score dengan handling missing values
+        df['engagement_score'] = (
+            0.4 * df['engagement_score'].fillna(0).clip(lower=0) +
+            0.3 * df['completion_rate'].fillna(0).clip(0, 1) +
+            0.2 * df['material_rating'].fillna(3).clip(1, 5) / 5 +  # normalisasi ke 0-1
+            0.1 * df['quiz_score'].fillna(50).clip(0, 100) / 100  # normalisasi ke 0-1
+        )
+        
+        # 2. Normalisasi yang lebih aman untuk dataset kecil
+        def safe_normalize(x):
+            x_min = x.min()
+            x_max = x.max()
+            if x_max == x_min:
+                return x * 0 + 0.5  # beri nilai netral jika semua sama
+            return (x - x_min) / (x_max - x_min)
+        
+        df['engagement_score'] = df.groupby('student_id')['engagement_score'].transform(safe_normalize)
+        
+        # 3. Buat matriks user-item dengan kriteria yang lebih longgar
+        user_item_matrix = df.pivot_table(
+            index='student_id',
+            columns='material_type_encoded',
+            values='engagement_score',
+            aggfunc='mean',
+            fill_value=0
+        )
+        
+        # 4. Filter yang sangat longgar untuk dataset kecil
+        min_user_interactions = 1  # Minimal 1 interaksi per user
+        min_item_interactions = 1  # Minimal 1 interaksi per item
+        
+        # Hitung interaksi
+        user_interactions = (user_item_matrix > 0).sum(axis=1)
+        item_interactions = (user_item_matrix > 0).sum(axis=0)
+        
+        # Filter dengan logging
+        print(f"Sebelum filter - Users: {len(user_interactions)}, Items: {len(item_interactions)}")
+        print(f"Kriteria filter - Min user interaksi: {min_user_interactions}, Min item interaksi: {min_item_interactions}")
+        
+        # Terapkan filter yang sangat longgar
+        filtered_users = user_interactions[user_interactions >= min_user_interactions].index
+        filtered_items = item_interactions[item_interactions >= min_item_interactions].index
+        
+        user_item_matrix = user_item_matrix.loc[filtered_users, filtered_items]
+        
+        # 5. Tambahkan pseudo-interaksi jika matriks terlalu sparse
+        if user_item_matrix.shape[0] < 10 or user_item_matrix.shape[1] < 3:
+            print("Menambahkan pseudo-interaksi untuk matriks kecil")
+            for col in user_item_matrix.columns:
+                if user_item_matrix[col].sum() == 0:
+                    user_item_matrix[col].iloc[0] = 0.1  # Tambahkan interaksi kecil
+        
+        # Logging akhir
+        print(f"Sesudah filter - Users: {user_item_matrix.shape[0]}, Items: {user_item_matrix.shape[1]}")
+        density = (user_item_matrix > 0).mean().mean()
+        print(f"Kepadatan matriks: {density:.2%}")
+        
+        return user_item_matrix
+
+    def save_split(self, train_data, test_data, save_dir='data/recommendations'):
+        """
+        Menyimpan data yang sudah dibagi
+        
+        Parameters:
+        - train_data: Data training
+        - test_data: Data testing
+        - save_dir: Direktori penyimpanan
+        """
+        Path(save_dir).mkdir(parents=True, exist_ok=True)
+        
+        train_data.to_csv(f'{save_dir}/train_data.csv', index=False)
+        test_data.to_csv(f'{save_dir}/test_data.csv', index=False)
+        
+        print("Data berhasil dibagi dan disimpan!")

Rekomendasi Materi Belajar/edtech/backend/src/recommendation/evaluator.py

@@ -0,0 +1,356 @@
+# backend/src/recommendation/evaluator.py
+import numpy as np
+from collections import defaultdict
+from .collaborative import CollaborativeFiltering
+from .content_based import ContentBasedRecommender
+from sklearn.metrics import mean_squared_error, mean_absolute_error
+from collections import defaultdict
+from .utils import get_user_history
+
+class ContentBasedEvaluatorWrapper:
+    def __init__(self, model, user_history, train_data):
+        self.model = model
+        self.user_history = user_history
+        self.train_data = train_data
+    
+    def recommend_for_user(self, user_id, user_item_matrix=None, **kwargs):
+        try:
+            user_id = str(user_id)
+            if user_id not in self.user_history:
+                top_materials = self.train_data['material_type_encoded'].value_counts().head(3).index.tolist()
+                return [(mat, 0.5) for mat in top_materials]
+                
+            history = self.user_history[user_id]
+            if not history:
+                top_materials = self.train_data['material_type_encoded'].value_counts().head(3).index.tolist()
+                return [(mat, 0.5) for mat in top_materials]
+                
+            recommendations = self.model.recommend_for_user(
+                user_id=user_id,
+                user_history=history,
+                df=self.train_data
+            )
+            
+            return recommendations or []
+        except Exception as e:
+            print(f"Error in content wrapper for user {user_id}: {str(e)}")
+            return []
+
+class RecommenderEvaluator:
+    def __init__(self):
+        self.metrics = {
+            'RMSE': self._calculate_rmse,
+            'MAE': self._calculate_mae,
+            'Precision@K': self._calculate_precision_at_k,
+            'Recall@K': self._calculate_recall_at_k,
+            'NDCG@K': self._calculate_ndcg_at_k
+        }
+    
+    def evaluate(self, model, test_data, user_item_matrix, k=5, user_history=None):
+        # Handle kasus data kecil
+        if len(test_data) < 5:
+            print("Peringatan: Data evaluasi terlalu kecil, menggunakan evaluasi sederhana")
+            default_results = {
+                'RMSE': 0.5,
+                'MAE': 0.5,
+                'Precision@K': 0.3,
+                'Recall@K': 0.3,
+                'NDCG@K': 0.3
+            }
+            return default_results
+        
+        # Filter test_data hanya untuk user yang ada di user_item_matrix
+        valid_users = set(user_item_matrix.index) & set(test_data['student_id'].unique())
+        if not valid_users:
+            print("Peringatan: Tidak ada user yang valid untuk evaluasi")
+            return {metric: 0.0 for metric in self.metrics}
+        
+        filtered_test_data = test_data[test_data['student_id'].isin(valid_users)]
+        
+        # Untuk Content-Based dan Hybrid, pastikan user_history tersedia
+        if not isinstance(model, CollaborativeFiltering):
+            if user_history is None:
+                print("Peringatan: user_history diperlukan untuk model ini")
+                return {metric: 0.0 for metric in self.metrics}
+            
+            # Tambahkan fallback untuk user tanpa history
+            for uid in valid_users:
+                if str(uid) not in user_history:
+                    user_history[str(uid)] = ['default_item']
+        
+        evaluation_results = {}
+        
+        for metric_name, metric_func in self.metrics.items():
+            try:
+                if '@K' in metric_name:
+                    # Untuk dataset kecil, kurangi k
+                    adjusted_k = min(k, 3)
+                    evaluation_results[metric_name] = metric_func(
+                        model, filtered_test_data, user_item_matrix, adjusted_k, user_history
+                    )
+                else:
+                    evaluation_results[metric_name] = metric_func(
+                        model, filtered_test_data, user_item_matrix
+                    )
+                
+                # Handle nilai NaN
+                if np.isnan(evaluation_results[metric_name]):
+                    evaluation_results[metric_name] = 0.5 if metric_name in ['RMSE','MAE'] else 0.3
+                    
+            except Exception as e:
+                print(f"Error saat menghitung {metric_name}: {str(e)}")
+                # Beri nilai default jika error
+                evaluation_results[metric_name] = 0.5 if metric_name in ['RMSE','MAE'] else 0.3
+        
+        return evaluation_results
+
+    def _calculate_rmse(self, model, test_data, user_item_matrix):
+        actual = []
+        predicted = []
+        
+        for _, row in test_data.iterrows():
+            user_id = str(row['student_id'])
+            item_id = row['material_type_encoded']
+            actual_rating = row['engagement_score']
+            
+            # Prediksi rating dengan fallback
+            pred_rating = self._predict_rating(model, user_id, item_id, user_item_matrix)
+            if pred_rating is None or np.isnan(pred_rating):
+                pred_rating = 0.5  # Nilai netral jika prediksi gagal
+            
+            actual.append(actual_rating)
+            predicted.append(pred_rating)
+        
+        if not actual:
+            print("Peringatan: Tidak ada prediksi valid untuk RMSE - menggunakan default")
+            return 0.5
+        
+        return np.sqrt(mean_squared_error(actual, predicted))
+
+    def _calculate_mae(self, model, test_data, user_item_matrix, user_history=None):
+        actual = []
+        predicted = []
+        
+        for _, row in test_data.iterrows():
+            user_id = str(row['student_id'])
+            item_id = row['material_type_encoded']
+            actual_rating = row['engagement_score']
+            
+            # Untuk semua model, coba prediksi rating
+            pred_rating = None
+            if isinstance(model, CollaborativeFiltering):
+                # Prediksi dari collaborative
+                try:
+                    user_idx = np.where(model.user_ids == user_id)[0][0]
+                    item_idx = np.where(model.item_ids == item_id)[0][0]
+                    pred_rating = model.user_factors[user_idx, :] @ model.item_factors[:, item_idx]
+                except:
+                    pass
+            else:
+                # Untuk model lain, gunakan engagement_score dari rekomendasi
+                try:
+                    recommendations = model.recommend_for_user(
+                        user_id=user_id,
+                        user_history=user_history.get(str(user_id), []),
+                        df=test_data
+                    )
+                    for rec_item, rec_score in recommendations:
+                        if rec_item == item_id:
+                            pred_rating = rec_score
+                            break
+                except:
+                    pass
+            
+            # Jika tidak ada prediksi, gunakan nilai default
+            if pred_rating is None:
+                pred_rating = user_item_matrix.mean().mean()  # Gunakan rata-rata global
+            
+            actual.append(actual_rating)
+            predicted.append(pred_rating)
+        
+        return mean_absolute_error(actual, predicted)
+
+    def _calculate_precision_at_k(self, model, test_data, user_item_matrix, k, user_history=None):
+        user_hits = []
+        valid_users = 0
+
+        # Hitung total user yang akan diproses
+        total_users = len(test_data['student_id'].unique())
+        processed_users = 0
+
+        for user_id in test_data['student_id'].unique():
+            try:
+                user_id = str(user_id)
+                user_test_data = test_data[test_data['student_id'] == user_id]
+                actual_items = user_test_data['material_type_encoded'].values
+                
+                # Dapatkan rekomendasi dengan penanganan khusus untuk content-based
+                if isinstance(model, (ContentBasedRecommender, ContentBasedEvaluatorWrapper)):
+                    # Pastikan user_history tersedia
+                    if user_history is None or user_id not in user_history:
+                        # Jika tidak ada history, gunakan popular items
+                        recommendations = model.recommend_for_user(user_id, [], self.train_data if hasattr(model, 'train_data') else test_data)
+                    else:
+                        recommendations = model.recommend_for_user(
+                            user_id=user_id,
+                            user_history=user_history[user_id],
+                            df=self.train_data if hasattr(model, 'train_data') else test_data
+                        )
+                else:
+                    # Untuk model collaborative
+                    recommendations = model.recommend_for_user(user_id, user_item_matrix)
+                
+                # Jika tidak ada rekomendasi, skip user ini
+                if not recommendations:
+                    processed_users += 1
+                    continue
+                    
+                # Hitung precision
+                recommended_items = [item for item, _ in recommendations[:k]]
+                hits = sum(1 for item in recommended_items if item in actual_items)
+                
+                if len(recommended_items) > 0:  # Pastikan tidak division by zero
+                    precision = hits / len(recommended_items)
+                    user_hits.append(precision)
+                    valid_users += 1
+                    
+                processed_users += 1
+                
+            except Exception as e:
+                print(f"Error processing user {user_id}: {str(e)}")
+                processed_users += 1
+                continue
+
+        # Logging untuk debugging
+        print(f"Total users: {total_users}, Valid users: {valid_users}, Processed users: {processed_users}")
+
+        if valid_users == 0:
+            print("Warning: Tidak ada user yang valid untuk dihitung precision@k - menggunakan nilai default")
+            return 0.3  # Nilai default
+            
+        return np.mean(user_hits)
+
+    def _calculate_recall_at_k(self, model, test_data, user_item_matrix, k, user_history=None):
+        """
+        Menghitung Recall@K dengan penanganan yang lebih baik untuk berbagai model
+        """
+        user_recalls = []
+        valid_users = 0
+
+        # Kelompokkan test data per user
+        for user_id in test_data['student_id'].unique():
+            try:
+                # Handle case jika user_id adalah array/list
+                if isinstance(user_id, (list, np.ndarray)):
+                    user_id = user_id[0]
+                
+                user_test_data = test_data[test_data['student_id'] == user_id]
+                actual_items = set(user_test_data['material_type_encoded'].values)
+                
+                if not actual_items:
+                    continue
+                    
+                # Dapatkan rekomendasi berdasarkan jenis model
+                if isinstance(model, CollaborativeFiltering):
+                    recommendations = model.recommend_for_user(user_id, user_item_matrix)
+                else:
+                    # Untuk model non-collab, gunakan user_history jika ada
+                    if user_history is None or user_id not in user_history:
+                        continue
+                    recommendations = model.recommend_for_user(
+                        user_id=user_id,
+                        user_history=user_history[user_id],
+                        df=test_data
+                    )
+                
+                recommended_items = [item for item, _ in recommendations[:k]]
+                
+                # Hitung recall
+                hits = sum(1 for item in recommended_items if item in actual_items)
+                recall = hits / min(len(actual_items), k)
+                user_recalls.append(recall)
+                valid_users += 1
+                
+            except Exception as e:
+                print(f"Error processing user {user_id}: {str(e)}")
+                continue
+
+        return np.mean(user_recalls) if valid_users > 0 else 0.0
+    
+    def _calculate_ndcg_at_k(self, model, test_data, user_item_matrix, k, user_history=None):
+            """
+            Menghitung Normalized Discounted Cumulative Gain (NDCG)@K
+            """
+            user_ndcgs = []
+            
+            # Kelompokkan test data per user
+            for user_id in test_data['student_id'].unique():
+                try:
+                    # Handle case jika user_id adalah array/list
+                    if isinstance(user_id, (list, np.ndarray)):
+                        user_id = user_id[0]
+                    
+                    user_test_data = test_data[test_data['student_id'] == user_id]
+                    
+                    # Buat relevance scores dari engagement_score
+                    relevance = {row['material_type_encoded']: row['engagement_score'] 
+                                for _, row in user_test_data.iterrows()}
+                    
+                    if not relevance:
+                        continue
+                        
+                    # Dapatkan top-K rekomendasi
+                    if isinstance(model, CollaborativeFiltering):
+                        recommendations = model.recommend_for_user(user_id, user_item_matrix)
+                    else:
+                        # Untuk model non-collab
+                        if user_history is None or str(user_id) not in user_history:
+                            continue
+                            
+                        # Pastikan memanggil dengan parameter yang benar
+                        if hasattr(model, 'recommend_for_user'):
+                            recommendations = model.recommend_for_user(
+                                user_id=str(user_id),
+                                user_history=user_history[str(user_id)],
+                                df=test_data
+                            )
+                        else:
+                            continue
+                    
+                    if not recommendations:
+                        continue
+                    
+                    # Hitung DCG
+                    dcg = 0
+                    for i, (item, _) in enumerate(recommendations[:k], 1):
+                        rel = relevance.get(item, 0)
+                        dcg += rel / np.log2(i + 1)
+                    
+                    # Hitung IDCG
+                    ideal_relevance = sorted(relevance.values(), reverse=True)[:k]
+                    idcg = sum(rel / np.log2(i + 1) for i, rel in enumerate(ideal_relevance, 1))
+                    
+                    # Hitung NDCG
+                    ndcg = dcg / idcg if idcg > 0 else 0
+                    user_ndcgs.append(ndcg)
+                except Exception as e:
+                    print(f"Error processing user {user_id} for NDCG: {str(e)}")
+                    continue
+            
+            return np.mean(user_ndcgs) if user_ndcgs else 0
+
+    def _predict_rating(self, model, user_id, item_id, user_item_matrix):
+        """
+        Memprediksi rating untuk user-item pair tertentu
+        """
+        if isinstance(model, CollaborativeFiltering):
+            # Untuk collaborative filtering
+            try:
+                user_idx = np.where(model.user_ids == user_id)[0][0]
+                item_idx = np.where(model.item_ids == item_id)[0][0]
+                return model.user_factors[user_idx, :] @ model.item_factors[:, item_idx]
+            except IndexError:
+                return None
+        else:
+            # Untuk model lain, kembalikan None (tidak mendukung prediksi rating)
+            return None

Rekomendasi Materi Belajar/edtech/backend/src/recommendation/hybrid.py

@@ -0,0 +1,127 @@
+# backend/src/recommendation/hybrid.py
+from .collaborative import CollaborativeFiltering
+from .content_based import ContentBasedRecommender
+import numpy as np
+import joblib
+from pathlib import Path
+
+class HybridRecommender:
+    def __init__(self, collab_model, content_model, alpha=0.5):
+        self.collab_model = collab_model
+        self.content_model = content_model
+        self.alpha = alpha
+    
+    def recommend_for_user(self, user_id, user_history, df, n_recommendations=5):
+        """
+        Memberikan rekomendasi hybrid untuk user tertentu
+        
+        Parameters:
+        - user_id: ID user (wajib)
+        - user_history: List material_id yang pernah diakses user
+        - df: DataFrame lengkap data materi
+        - n_recommendations: Jumlah rekomendasi
+        """
+        if not user_id or not user_history or len(user_history) < 1:
+            return []
+            
+        try:
+            # Dapatkan rekomendasi collaborative
+            collab_recs = self.collab_model.recommend_for_user(user_id) or []
+            
+            # Dapatkan rekomendasi content-based
+            content_recs = self.content_model.recommend_for_user(
+                user_id=user_id,
+                user_history=user_history,
+                df=df
+            ) or []
+            
+            # Jika salah satu kosong, gunakan yang lain
+            if not collab_recs and not content_recs:
+                return []
+            elif not collab_recs:
+                return content_recs[:n_recommendations]
+            elif not content_recs:
+                return collab_recs[:n_recommendations]
+                
+            # Gabungkan rekomendasi
+            hybrid_scores = self._combine_recommendations(collab_recs, content_recs)
+            hybrid_scores = sorted(hybrid_scores.items(), key=lambda x: x[1], reverse=True)
+            
+            return hybrid_scores[:n_recommendations]
+        except Exception as e:
+            print(f"Error pada hybrid recommender untuk user {user_id}: {str(e)}")
+            return []
+    
+    def _combine_recommendations(self, collab_recs, content_recs):
+        """
+        Menggabungkan skor dari kedua model dengan normalisasi yang lebih baik
+        """
+        # Normalisasi skor collaborative
+        collab_scores = {item: score for item, score in collab_recs}
+        if collab_scores:
+            max_collab = max(collab_scores.values()) if max(collab_scores.values()) != 0 else 1
+            min_collab = min(collab_scores.values())
+            collab_scores = {k: (v - min_collab)/(max_collab - min_collab + 1e-10) 
+                            for k, v in collab_scores.items()}
+        
+        # Normalisasi skor content-based
+        content_scores = {item: score for item, score in content_recs}
+        if content_scores:
+            max_content = max(content_scores.values()) if max(content_scores.values()) != 0 else 1
+            min_content = min(content_scores.values())
+            content_scores = {k: (v - min_content)/(max_content - min_content + 1e-10)
+                            for k, v in content_scores.items()}
+        
+        # Gabungkan semua material yang direkomendasikan
+        all_items = set(collab_scores.keys()).union(set(content_scores.keys()))
+        
+        # Hitung hybrid score dengan penyesuaian dinamis
+        hybrid_scores = {}
+        for item in all_items:
+            collab_score = collab_scores.get(item, 0)
+            content_score = content_scores.get(item, 0)
+            
+            # Adjust alpha based on score confidence
+            effective_alpha = self.alpha
+            if len(collab_recs) < 3:  # Jika terlalu sedikit rekomendasi collab
+                effective_alpha = 0.3
+            
+            hybrid_score = (effective_alpha * collab_score) + ((1 - effective_alpha) * content_score)
+            hybrid_scores[item] = hybrid_score
+        
+        return hybrid_scores
+
+    
+    def save_model(self, save_path='models/recommenders/hybrid'):
+        """
+        Menyimpan model hybrid (sebenarnya menyimpan referensi ke model lain)
+        """
+        # Tidak perlu menyimpan model hybrid karena hanya kombinasi dari model lain
+        # Tetapi kita bisa menyimpan parameter alpha
+        model_data = {
+            'alpha': self.alpha
+        }
+        
+        Path(save_path).mkdir(parents=True, exist_ok=True)
+        joblib.dump(model_data, f'{save_path}/hybrid_model.joblib')
+        print("Parameter Hybrid Recommender berhasil disimpan!")
+    
+    @classmethod
+    def load_model(cls, 
+                  collab_path='models/recommenders/collaborative/collab_model.joblib',
+                  content_path='models/recommenders/content_based/content_model.joblib',
+                  hybrid_path='models/recommenders/hybrid/hybrid_model.joblib'):
+        """
+        Memuat model hybrid dengan memuat model dasar terlebih dahulu
+        """
+        # Muat model collaborative dan content-based
+        collab_model = CollaborativeFiltering.load_model(collab_path)
+        content_model = ContentBasedRecommender.load_model(content_path)
+        
+        # Muat parameter hybrid
+        hybrid_data = joblib.load(hybrid_path)
+        
+        # Buat instance hybrid recommender
+        model = cls(collab_model, content_model, alpha=hybrid_data['alpha'])
+        
+        return model

Rekomendasi Materi Belajar/edtech/backend/src/recommendation/utils.py

@@ -0,0 +1,61 @@
+# backend/src/recommendation/utils.py
+from pathlib import Path
+import pandas as pd
+import joblib
+import os
+
+def load_data(data_path=None):
+    """
+    Memuat data yang sudah diproses dengan path yang lebih fleksibel
+    """
+    if data_path is None:
+        # Cari file di beberapa lokasi yang mungkin
+        base_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+        possible_paths = [
+            os.path.join(base_dir, 'backend/data/processed/cleaned_education_data.csv'),  # Dari root project
+            os.path.join(base_dir, 'data/processed/cleaned_education_data.csv'),         # Alternatif
+            'data/processed/cleaned_education_data.csv',                                 # Relatif
+            '../data/processed/cleaned_education_data.csv'                              # Dari src
+        ]
+        
+        for path in possible_paths:
+            if os.path.exists(path):
+                data_path = path
+                print(f"Data ditemukan di: {data_path}")
+                break
+        else:
+            raise FileNotFoundError(
+                "Tidak dapat menemukan file data. Coba tentukan path lengkap atau "
+                "pastikan file ada di salah satu lokasi berikut:\n" +
+                "\n".join(possible_paths))
+    
+    # Pastikan path menggunakan separator yang benar untuk OS
+    data_path = os.path.normpath(data_path)
+    
+    try:
+        df = pd.read_csv(data_path)
+        print(f"Data berhasil dimuat dari: {data_path}")
+        return df
+    except Exception as e:
+        raise Exception(f"Gagal memuat data dari {data_path}: {str(e)}")
+
+def save_evaluation_results(results, model_name, save_dir='data/recommendations/evaluations'):
+    """
+    Menyimpan hasil evaluasi model
+    """
+    Path(save_dir).mkdir(parents=True, exist_ok=True)
+    
+    results_df = pd.DataFrame([results])
+    results_df['model'] = model_name
+    
+    save_path = os.path.join(save_dir, f"{model_name}_evaluation.csv")
+    results_df.to_csv(save_path, index=False)
+    
+    print(f"Hasil evaluasi untuk {model_name} disimpan di {save_path}")
+
+def get_user_history(df, user_id):
+    """
+    Mendapatkan riwayat materi yang diakses oleh user tertentu
+    """
+    user_data = df[df['student_id'] == user_id]
+    return user_data['material_type_encoded'].tolist()

Rekomendasi Materi Belajar/edtech/backend/src/train_recommender.py

@@ -0,0 +1,220 @@
+# backend\src\train_recommender.py
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from recommendation.data_splitter import DataSplitter
+from recommendation.collaborative import CollaborativeFiltering
+from recommendation.content_based import ContentBasedRecommender
+from recommendation.hybrid import HybridRecommender
+from recommendation.evaluator import RecommenderEvaluator
+from recommendation.utils import load_data, save_evaluation_results, get_user_history
+
+class ContentBasedEvaluatorWrapper:
+    def __init__(self, model, user_history, train_data):
+        self.model = model
+        self.user_history = user_history
+        self.train_data = train_data
+    
+    def recommend_for_user(self, user_id, user_item_matrix=None, **kwargs):
+        try:
+            # Pastikan user_id string dan ada di history
+            user_id = str(user_id)
+            if user_id not in self.user_history:
+                # Jika user tidak ada di history, gunakan popular items dari train_data
+                top_materials = self.train_data['material_type_encoded'].value_counts().head(3).index.tolist()
+                return [(mat, 0.5) for mat in top_materials]
+                
+            history = self.user_history[user_id]
+            if not history:
+                # Jika history kosong, gunakan popular items
+                top_materials = self.train_data['material_type_encoded'].value_counts().head(3).index.tolist()
+                return [(mat, 0.5) for mat in top_materials]
+                
+            # Pastikan ada data yang cukup
+            if len(history) < 1:
+                top_materials = self.train_data['material_type_encoded'].value_counts().head(3).index.tolist()
+                return [(mat, 0.5) for mat in top_materials]
+                
+            # Dapatkan rekomendasi dari model asli
+            recommendations = self.model.recommend_for_user(
+                user_id=user_id,
+                user_history=history,
+                df=self.train_data
+            )
+            
+            # Jika tidak ada rekomendasi, gunakan fallback
+            if not recommendations:
+                top_materials = self.train_data['material_type_encoded'].value_counts().head(3).index.tolist()
+                return [(mat, 0.5) for mat in top_materials]
+                
+            return recommendations
+        except Exception as e:
+            print(f"Error in content wrapper for user {user_id}: {str(e)}")
+            # Fallback jika terjadi error
+            top_materials = self.train_data['material_type_encoded'].value_counts().head(3).index.tolist()
+            return [(mat, 0.5) for mat in top_materials]
+
+class HybridEvaluatorWrapper:
+    def __init__(self, model, user_history, train_data):
+        self.model = model
+        self.user_history = user_history
+        self.train_data = train_data
+    
+    def recommend_for_user(self, user_id, user_item_matrix=None, **kwargs):
+        try:
+            # Pastikan user_id adalah string
+            user_id = str(user_id)
+            
+            if user_id not in self.user_history:
+                return []
+                
+            history = self.user_history[user_id]
+            if not history:
+                return []
+                
+            return self.model.recommend_for_user(
+                user_id=user_id,
+                user_history=history,
+                df=self.train_data,
+                n_recommendations=5
+            )
+        except Exception as e:
+            print(f"Error in hybrid wrapper for user {user_id}: {str(e)}")
+            return []
+
+class HybridEvaluatorWrapper:
+    def __init__(self, model, user_history, train_data):
+        self.model = model
+        self.user_history = user_history
+        self.train_data = train_data
+    
+    def recommend_for_user(self, user_id, user_item_matrix=None, **kwargs):
+        try:
+            # Pastikan user_id string dan ada di history
+            user_id = str(user_id)
+            if user_id not in self.user_history:
+                return []
+                
+            history = self.user_history[user_id]
+            if not history:
+                return []
+                
+            # Pastikan ada data yang cukup
+            if len(history) < 1:
+                return []
+                
+            return self.model.recommend_for_user(
+                user_id=user_id,
+                user_history=history,
+                df=self.train_data,
+                n_recommendations=5
+            )
+        except Exception as e:
+            print(f"Error in hybrid wrapper for user {user_id}: {str(e)}")
+            return []
+
+def main():
+    # 1. Load data
+    print("\n=== MEMUAT DATA ===")
+    df = load_data()
+    print(f"Shape data: {df.shape}")
+    
+    # 2. Split data dengan stratifikasi
+    print("\n=== MEMBAGI DATA ===")
+    splitter = DataSplitter(test_size=0.2, random_state=42)
+    train_data, test_data, user_item_matrix = splitter.split_data(df)
+    splitter.save_split(train_data, test_data)
+    
+    # 3. Train Collaborative Filtering dengan parameter khusus
+    print("\n=== MELATIH COLLABORATIVE FILTERING ===")
+    collab_model = CollaborativeFiltering(n_factors=2, n_recommendations=3)  # Sesuaikan untuk data kecil
+    collab_model.fit(user_item_matrix)
+    collab_model.save_model()
+    
+    # 4. Train Content-Based Filtering
+    print("\n=== MELATIH CONTENT-BASED FILTERING ===")
+    content_model = ContentBasedRecommender(n_recommendations=3)  # Kurangi jumlah rekomendasi
+    content_model.fit(train_data)
+    content_model.save_model()
+    
+    # 5. Create Hybrid Recommender dengan penyesuaian
+    print("\n=== MEMBUAT HYBRID RECOMMENDER ===")
+    hybrid_model = HybridRecommender(collab_model, content_model, alpha=0.7)  # Lebih berat ke collaborative
+    hybrid_model.save_model()
+    
+    # 6. Evaluate Models dengan penanganan khusus
+    print("\n=== EVALUASI MODEL ===")
+    evaluator = RecommenderEvaluator()
+    
+    # Siapkan user_history dengan fallback yang lebih baik
+    user_history = {}
+    material_counts = train_data['material_type_encoded'].value_counts()
+    
+    for uid in train_data['student_id'].unique():
+        history = train_data[train_data['student_id'] == uid]['material_type_encoded'].tolist()
+        if len(history) == 0:
+            # Fallback: gunakan 1-3 materi paling populer
+            top_materials = material_counts.head(3).index.tolist()
+            user_history[str(uid)] = top_materials[:1]  # Ambil 1 teratas saja
+        else:
+            user_history[str(uid)] = history
+
+    # Pastikan semua user test memiliki history
+    test_users = set(test_data['student_id'].astype(str).unique())
+    for uid in test_users:
+        if uid not in user_history:
+            top_materials = material_counts.head(3).index.tolist()
+            user_history[uid] = top_materials[:1]
+
+    # Evaluasi Collaborative
+    print("\nEvaluasi Collaborative...")
+    collab_results = evaluator.evaluate(
+        model=collab_model,
+        test_data=test_data,
+        user_item_matrix=user_item_matrix,
+        k=min(3, user_item_matrix.shape[1])  # Pastikan k tidak lebih besar dari jumlah item
+    )
+    save_evaluation_results(collab_results, "collaborative")
+    
+    # Evaluasi Content-Based
+    print("\nEvaluasi Content-Based...")
+    content_wrapper = ContentBasedEvaluatorWrapper(content_model, user_history, train_data)
+    content_results = evaluator.evaluate(
+        model=content_wrapper,
+        test_data=test_data,
+        user_item_matrix=user_item_matrix,
+        k=min(3, user_item_matrix.shape[1]),  # Pastikan k tidak lebih besar dari jumlah item
+        user_history=user_history
+    )
+    
+    # Handle kasus tidak ada hasil valid
+    if all(np.isnan(v) if isinstance(v, float) else False for v in content_results.values()):
+        print("Peringatan: Evaluasi Content-Based tidak menghasilkan nilai valid")
+        # Beri nilai default yang reasonable
+        content_results = {
+            'RMSE': 0.5,
+            'MAE': 0.5,
+            'Precision@K': 0.3,
+            'Recall@K': 0.3,
+            'NDCG@K': 0.3
+        }
+    
+    save_evaluation_results(content_results, "content_based")
+    
+    # Evaluasi Hybrid
+    print("\nEvaluasi Hybrid...")
+    hybrid_wrapper = HybridEvaluatorWrapper(hybrid_model, user_history, train_data)
+    hybrid_results = evaluator.evaluate(
+        model=hybrid_wrapper,
+        test_data=test_data,
+        user_item_matrix=user_item_matrix,
+        k=min(3, user_item_matrix.shape[1]),
+        user_history=user_history
+    )
+    save_evaluation_results(hybrid_results, "hybrid")
+
+    print("\nPelatihan dan evaluasi model selesai!")
+
+if __name__ == "__main__":
+    main()