Dokumentasi Search Engine

def _build_inverted_index(self):
    """
    Build inverted index: term -> set of document IDs
    """
    print("Building inverted index...")
    
    for idx, doc in enumerate(self.documents):
        # Combine title, description, and genres for indexing
        text = f"{doc['title']} {doc['description']} {doc['listed_in']}"
        tokens = self._preprocess_text(text)
        
        # Add terms to inverted index
        for term in set(tokens):  # Use set to avoid duplicates
            self.inverted_index[term].add(idx)
    
    print(f"Inverted index built with {len(self.inverted_index)} terms")

def _calculate_tf(self, tokens: List[str]) -> Dict[str, float]:
    """
    Calculate Term Frequency (TF)
    TF = (number of times term appears) / (total terms)
    """
    tf = {}
    total_terms = len(tokens)
    
    if total_terms == 0:
        return tf
    
    term_counts = Counter(tokens)
    
    for term, count in term_counts.items():
        tf[term] = count / total_terms
    
    return tf

def _calculate_idf(self):
    """
    Calculate Inverse Document Frequency (IDF)
    IDF = log(total documents / documents containing term)
    """
    total_docs = len(self.documents)
    
    for term, doc_ids in self.inverted_index.items():
        self.idf[term] = math.log(total_docs / len(doc_ids))

def _calculate_tf_idf(self):
    """
    Calculate TF-IDF for all documents
    TF-IDF = TF * IDF
    """
    # Calculate IDF
    self._calculate_idf()
    
    # Calculate TF-IDF for each document
    for idx, doc in enumerate(self.documents):
        text = f"{doc['title']} {doc['description']} {doc['listed_in']}"
        tokens = self._preprocess_text(text)
        
        # Calculate TF
        tf = self._calculate_tf(tokens)
        
        # Calculate TF-IDF
        tf_idf_vector = {}
        for term, tf_value in tf.items():
            if term in self.idf:
                tf_idf_vector[term] = tf_value * self.idf[term]
        
        self.document_vectors[idx] = tf_idf_vector

def _cosine_similarity(self, vec1: Dict[str, float], vec2: Dict[str, float]) -> float:
    """
    Calculate cosine similarity between two vectors
    Cosine Similarity = (A · B) / (||A|| * ||B||)
    """
    # Calculate dot product
    dot_product = sum(
        vec1.get(term, 0) * vec2.get(term, 0) 
        for term in set(vec1.keys()) | set(vec2.keys())
    )
    
    # Calculate magnitudes
    magnitude1 = math.sqrt(sum(val ** 2 for val in vec1.values()))
    magnitude2 = math.sqrt(sum(val ** 2 for val in vec2.values()))
    
    if magnitude1 == 0 or magnitude2 == 0:
        return 0.0
    
    return dot_product / (magnitude1 * magnitude2)

def _expand_query(self, query: str) -> List[str]:
    """
    Query Expansion: Add related terms based on similar documents
    """
    query_tokens = self._preprocess_text(query)
    
    if not query_tokens:
        return query_tokens
    
    # Find documents that contain any query term
    candidate_docs = set()
    for term in query_tokens:
        if term in self.inverted_index:
            candidate_docs.update(self.inverted_index[term])
    
    if not candidate_docs:
        return query_tokens
    
    # Find most frequent terms in top candidate documents
    term_freq = Counter()
    for doc_id in list(candidate_docs)[:20]:  # Use top 20 candidates
        doc = self.documents[doc_id]
        text = f"{doc['title']} {doc['description']} {doc['listed_in']}"
        tokens = self._preprocess_text(text)
        term_freq.update(tokens)
    
    # Add top 3 most frequent terms not in original query
    expanded_terms = []
    for term, _ in term_freq.most_common(10):
        if term not in query_tokens and len(term) > 2:
            expanded_terms.append(term)
            if len(expanded_terms) >= 3:
                break
    
    # Combine original query with expanded terms
    return query_tokens + expanded_terms

User Query
    ↓
[Preprocessing]
    ↓
[Query Expansion]
    ↓
[TF-IDF Vectorization]
    ↓
[Inverted Index Lookup] → Candidate Documents
    ↓
[Cosine Similarity Calculation]
    ↓
[Ranking by Score]
    ↓
Top-K Results → Display to User

class NetflixSearchEngine:
    def __init__(self, csv_path: str)
        # Initialize dan load data
    
    def _load_data(self, csv_path: str)
        # Load CSV file
    
    def _preprocess_text(self, text: str) -> List[str]
        # Text preprocessing
    
    def _build_inverted_index(self)
        # Build inverted index structure
    
    def _calculate_tf(self, tokens: List[str]) -> Dict[str, float]
        # Calculate Term Frequency
    
    def _calculate_idf(self)
        # Calculate Inverse Document Frequency
    
    def _calculate_tf_idf(self)
        # Calculate TF-IDF for all documents
    
    def _cosine_similarity(self, vec1, vec2) -> float
        # Calculate cosine similarity
    
    def _expand_query(self, query: str) -> List[str]
        # Query expansion logic
    
    def search(self, query: str, top_k: int = 10) -> Dict
        # Main search function
    
    def get_statistics(self) -> Dict
        # Get system statistics

@app.route('/')
def index():
    # Render halaman utama

@app.route('/search', methods=['POST'])
def search():
    # Handle search request
    # Return JSON results

@app.route('/stats')
def stats():
    # Return system statistics
    
@app.route('/documentation')
def documentation():
    # Render halaman dokumentasi