Update course_search.py

course_search.py

@@ -8,7 +8,6 @@ from transformers import AutoModel, AutoTokenizer
 class CourseSearchSystem:
     def __init__(self):
         self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        # Load model and tokenizer directly using transformers
         self.model_name = 'sentence-transformers/all-MiniLM-L6-v2'
         self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
         self.model = AutoModel.from_pretrained(self.model_name).to(self.device)
@@ -22,18 +21,13 @@ class CourseSearchSystem:
 
     def get_embeddings(self, texts: List[str]) -> np.ndarray:
         """Get embeddings for a list of texts"""
-        # Tokenize sentences
         encoded_input = self.tokenizer(texts, padding=True, truncation=True, return_tensors='pt', max_length=512)
         encoded_input = {k: v.to(self.device) for k, v in encoded_input.items()}
 
-        # Compute token embeddings
         with torch.no_grad():
             model_output = self.model(**encoded_input)
 
-        # Perform pooling
         sentence_embeddings = self.mean_pooling(model_output, encoded_input['attention_mask'])
-        
-        # Normalize embeddings
         sentence_embeddings = torch.nn.functional.normalize(sentence_embeddings, p=2, dim=1)
         
         return sentence_embeddings.cpu().numpy()
@@ -71,65 +65,33 @@ class CourseSearchSystem:
         """Load and prepare the course data and generate embeddings"""
         self.courses_df = self.prepare_course_data(df)
         self.course_embeddings = self.get_embeddings(self.courses_df['search_text'].tolist())
-    
-    def _get_course_emoji(self, course_name: str) -> str:
-        """Return appropriate emoji based on course topic"""
-        emoji_mapping = {
-            'machine learning': '🤖',
-            'deep learning': '🧠',
-            'python': '🐍',
-            'data': '📊',
-            'nlp': '📝',
-            'computer vision': '👁️',
-            'genai': '✨',
-            'ethics': '⚖️',
-            'statistics': '📈',
-            'visualization': '📊',
-            'neural': '🔮',
-            'ai': '🤖'
-        }
-        
-        for key, emoji in emoji_mapping.items():
-            if key in course_name:
-                return emoji
-        return '📚'  # Default emoji for other courses
 
     def generate_response(self, query: str, results: List[Dict]) -> str:
-        """Generate an enhanced natural language response with course recommendations"""
+        """Generate a professional response with course recommendations"""
         response_parts = []
         
-        # Dynamic introduction based on number of results
+        # Introduction based on number of results
         if len(results) == 1:
-            response_parts.append(f"📚 I found an excellent free course matching your search for '{query}':")
+            response_parts.append(f"I found an excellent free course matching your search for '{query}':")
         else:
-            response_parts.append(f"📚 I found {len(results)} relevant free courses matching your search for '{query}':")
+            response_parts.append(f"I found {len(results)} relevant free courses matching your search for '{query}':")
         
         # Course details
         for i, result in enumerate(results, 1):
-            # Format course name with emoji based on topic
             course_name = result['course_name']
-            emoji = self._get_course_emoji(course_name.lower())
-            course_section = f"\n{emoji} **{i}. {course_name}**\n"
+            course_section = f"\n**{i}. {course_name}**\n"
             
-            # Clean rating display (out of 5)
+            # Clean rating display
             rating = result['ratings']
             rating_display = f"{rating}/5.0"
-            stars = "★" * int(rating) + ("½" if rating % 1 >= 0.5 else "")
-            stars = stars.ljust(5, "☆")
-            course_section += f"**Rating:** {stars} ({rating_display})\n"
+            course_section += f"**Rating:** {rating_display}\n"
             
-            # Add difficulty with color-coded emoji
-            difficulty_emoji = {
-                'Beginner': '🟢',
-                'Intermediate': '🟡',
-                'Advanced': '🔴'
-            }.get(result['difficulty'], '⚪')
-            course_section += f"**Level:** {difficulty_emoji} {result['difficulty']}\n"
+            # Add difficulty
+            course_section += f"**Level:** {result['difficulty']}\n"
             
             # Add duration if available
             if result['course_time']:
-                duration_emoji = '⏱️'
-                course_section += f"**Duration:** {duration_emoji} {result['course_time']} hours\n"
+                course_section += f"**Duration:** {result['course_time']} hours\n"
             
             # Format key takeaways with bullet points
             if result['key_takeaways'] and result['key_takeaways'] != 'Course details not available.':
@@ -139,27 +101,26 @@ class CourseSearchSystem:
                 for takeaway in takeaways:
                     cleaned = takeaway.strip('. ,')
                     if cleaned:
-                        # Limit takeaway length for better readability
                         if len(cleaned) > 100:
                             cleaned = cleaned[:97] + "..."
                         formatted_takeaways.append(f"• {cleaned}")
-                course_section += "\n".join(formatted_takeaways[:3])  # Limit to top 3 takeaways
+                course_section += "\n".join(formatted_takeaways[:3])
                 
                 if len(takeaways) > 3:
-                    course_section += "\n• *And more...*"
+                    course_section += "\n• And more..."
             
             # Add relevance score as a percentage
             similarity_percentage = int(result['similarity_score'] * 100)
-            course_section += f"\n**Match Score:** {'🎯' if similarity_percentage > 90 else '📊'} {similarity_percentage}%"
+            course_section += f"\n**Match Score:** {similarity_percentage}%"
             
-            # Add course link with clear CTA
-            course_section += f"\n\n➡️ [Start Learning Now]({result['url']})\n"
+            # Add course link
+            course_section += f"\n\n[Start Course]({result['url']})\n"
             
             response_parts.append(course_section)
         
-        # Add helpful conclusion with next steps
+        # Add helpful conclusion
         response_parts.append("\n---\n")
-        response_parts.append("💡 **Pro Tips:**")
+        response_parts.append("**Notes:**")
         response_parts.append("• Courses are sorted by relevance to your search")
         response_parts.append("• All courses are free and include hands-on projects")
         response_parts.append("• Certificates are provided upon completion")
@@ -168,16 +129,9 @@ class CourseSearchSystem:
     
     def search_courses(self, query: str, top_k: int = 5) -> str:
         """Search for courses and return formatted response"""
-        # Preprocess query
         query = self.preprocess_text(query)
-        
-        # Generate query embedding
         query_embedding = self.get_embeddings([query])[0]
-        
-        # Calculate similarities
         similarities = np.dot(self.course_embeddings, query_embedding)
-        
-        # Get top k results
         top_indices = np.argsort(similarities)[-top_k:][::-1]
         
         results = []
@@ -185,7 +139,7 @@ class CourseSearchSystem:
             course = self.courses_df.iloc[idx]
             results.append({
                 'course_name': course['Course Name'],
-                'key_takeaways': course['Key Takeaways'],
+                'key_takeaways': course['Key_Takeaways'],
                 'course_time': course['Course Time'],
                 'ratings': course['Ratings'],
                 'difficulty': course['Difficulty'],
@@ -193,25 +147,4 @@ class CourseSearchSystem:
                 'url': course['Website']
             })
         
-        # Generate formatted response
-        return self.generate_response(query, results)
-
-
-if __name__ == "__main__":
-    df = pd.read_csv('course_data.csv')
-    search_system = CourseSearchSystem()
-    search_system.load_and_prepare_data(df)
-    
-    test_queries = [
-        "machine learning for beginners",
-        "natural language processing",
-        "computer vision courses",
-        "data preprocessing tutorials",
-        "generative AI learning"
-    ]
-    
-    for query in test_queries:
-        print(f"\nTesting query: '{query}'\n")
-        response = search_system.search_courses(query, top_k=3)
-        print(response)
-        print("\n" + "="*80 + "\n")
+        return self.generate_response(query, results)