Update app.py

app.py

@@ -0,0 +1,143 @@
+df = pd.read_csv("Course_Recommender_system/cleaned_data.csv")
+
+bert_model = SentenceTransformer('all-MiniLM-L6-v2')
+df["course_embedding"] = df["Transformed_description"].apply(lambda x: bert_model.encode(x, convert_to_tensor=True))
+client = genai.Client(api_key='AIzaSyBxTbIk5Lwrjs8iPmiIZERmZ7VTwwCyizE')
+
+def recommend_courses(skills, interests, experience, education, time, certificates, careerpath):
+    try:
+        # Create initial user profile
+        user_profile = {
+            "skills": [s.strip() for s in skills.split(",") if s.strip()],
+            "interests": [s.strip() for s in interests.split(",") if s.strip()],
+            "experience": [s.strip() for s in experience.split(",") if s.strip()],
+            "education": [s.strip() for s in education.split(",") if s.strip()],
+            "time": [s.strip() for s in time.split(",") if s.strip()],
+            "certificates": [s.strip() for s in certificates.split(",") if s.strip()],
+            "careerpath": [s.strip() for s in careerpath.split(",") if s.strip()]
+        }
+
+        # Get skill level assessment
+        response = client.models.generate_content(
+            model="gemini-pro",
+            contents=f"""
+            Give the current skill level in one word out of 'beginner', 'intermediate', 'advanced'.
+            Here is the user profile: {user_profile}
+            strictly do not output any extra textual data."""
+        )
+        
+        CurrentSkill = response.text.strip().replace("\n", "")
+        user_profile["CurrentSkill"] = [CurrentSkill]
+
+        user_text = " ".join(user_profile["skills"] + user_profile["interests"] + user_profile["experience"] + user_profile["education"] + user_profile["time"] + user_profile["certificates"] + user_profile["careerpath"] + user_profile["CurrentSkill"])
+
+        # # Create weighted user text representation
+        # user_text = " ".join([
+        #     " ".join(user_profile["skills"]) * 3,
+        #     " ".join(user_profile["interests"]) * 2,
+        #     " ".join(user_profile["careerpath"]) * 2,
+        #     " ".join(user_profile["experience"]),
+        #     " ".join(user_profile["education"]),
+        #     " ".join(user_profile["certificates"]),
+        #     " ".join(user_profile["CurrentSkill"]) * 2
+        # ])
+
+        user_embedding = bert_model.encode(user_text, convert_to_tensor=True)
+        course_embeddings = torch.stack(df["course_embedding"].tolist())
+        similarities = cosine_similarity(user_embedding, course_embeddings)
+        # similarities = cosine_similarity(user_embedding.unsqueeze(0), course_embeddings)[0]
+
+        # Original weighting scheme
+
+        weights = {
+            "similarity": 0.6,
+            "rating": 0.2,
+            "difficulty": 0.1,
+            "time_to_complete": 0.1
+        }
+
+        df["normalized_rating"] = (df["course_rating"] - df["course_rating"].min()) / (
+            df["course_rating"].max() - df["course_rating"].min())
+        df["normalized_difficulty"] = 1 - (df["course_difficulty"] / df["course_difficulty"].max())
+
+        df["ranking_score"] = (
+            weights["similarity"] * similarities.cpu().numpy() +
+            weights["rating"] * df["normalized_rating"].values +
+            weights["difficulty"] * df["normalized_difficulty"].values
+        )
+
+        top_courses = df.sort_values(by="ranking_score", ascending=False).head(6)
+        output = top_courses["course_name"].tolist()
+
+        response2 = client.models.generate_content(
+            model="gemini-pro",
+            contents=f"""
+            Return a JSON object with this exact structure:
+            {{
+                "beginner": [
+                    {{"name": "course name", "url": "course url"}}
+                ],
+                "intermediate": [
+                    {{"name": "course name", "url": "course url"}}
+                ],
+                "advanced": [
+                    {{"name": "course name", "url": "course url"}}
+                ]
+            }}
+            
+            Categorize these courses: {output}
+
+            Add Url of the specific course from {df["course_url"]}
+            Based on:
+            - User skill level: {CurrentSkill}
+            - Course difficulties: {top_courses['normalized_difficulty'].tolist()}
+            - User skills: {user_profile['skills']}
+            
+            Categorise atleast one course for each beginner, intermediate and advanced.
+            Return ONLY valid JSON without any extra text.
+            """
+        )
+
+        try:
+            json_response = json.loads(response2.text.strip().replace('```json', '').replace('```', ''))
+            # Validate structure
+            for level in ['beginner', 'intermediate', 'advanced']:
+                if level not in json_response:
+                    json_response[level] = []
+                else:
+            # Ensure each course has name and url
+                    for course in json_response[level]:
+                        if not isinstance(course, dict) or 'name' not in course or 'url' not in course:
+                            json_response[level] = []
+                        break
+            return json_response
+        except:
+            return {
+                "beginner": [],
+                "intermediate": [],
+                "advanced": [],
+                "error": "Failed to categorize courses"
+            }
+
+    except Exception as e:
+        return {"error": str(e)}
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=recommend_courses,
+    inputs=[
+        gr.Textbox(label="Skills", placeholder="python, machine learning"),
+        gr.Textbox(label="Interests", placeholder="AI, data science"),
+        gr.Textbox(label="Experience", placeholder="2 years python"),
+        gr.Textbox(label="Education", placeholder="bachelor's in CS"),
+        gr.Textbox(label="Time Available", placeholder="6 months"),
+        gr.Textbox(label="Certificates", placeholder="AWS, GCP"),
+        gr.Textbox(label="Career Path", placeholder="ML engineer")
+    ],
+    outputs=gr.JSON(),
+    title="Personalized Course Recommender",
+    description="Enter your profile details to get course recommendations organized by difficulty level"
+)
+
+if __name__ == "__main__":
+    iface.launch(share=True)