#VisionTransformer #ViT #DeepLearning #ComputerVision #Transformers #AI #MachineLearning #MCQ #InterviewPrep

✉️ Our Telegram channels: https://t.iss.one/addlist/0f6vfFbEMdAwODBk

📱 Our WhatsApp channel: https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

✉️ Our Telegram channels: https://t.iss.one/addlist/0f6vfFbEMdAwODBk

📱 Our WhatsApp channel: https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

✉️ Our Telegram channels: https://t.iss.one/addlist/0f6vfFbEMdAwODBk

📱 Our WhatsApp channel: https://whatsapp.com/channel/0029VaC7Weq29753hpcggW2A

import redis
import numpy as np
from fastapi import FastAPI, Depends
from typing import Dict, List, Any
from lightfm import LightFM
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import json
import asyncio

# Configuration
REDIS_URL = "redis://localhost:6379/0"
app = FastAPI()
redis_client = redis.from_url(REDIS_URL)

class HybridRecommendationSystem:
    def __init__(self):
        self.model = LightFM(no_components=30, loss='warp')
        self.user_features = {}
        self.item_features = {}
        self.tfidf = TfidfVectorizer(max_features=1000)
        
    async def update_model(self, interactions: List[Dict], items: List[Dict]):
        """Incrementally update recommendation model."""
        # Simulate training data
        n_users = len(interactions)
        n_items = len(items)
        user_ids = [i['user_id'] for i in interactions]
        item_ids = [i['item_id'] for i in interactions]
        ratings = [i['rating'] for i in interactions]
        
        # Create sparse interaction matrix
        X = np.zeros((n_users, n_items))
        for u, i, r in zip(user_ids, item_ids, ratings):
            X[u, i] = r
            
        # Update model
        self.model.fit_partial(X)
        
    async def get_recommendations(self, user_id: int, n: int = 5) -> List[int]:
        """Generate recommendations using hybrid approach."""
        # Collaborative filtering
        scores_cf = self.model.predict(user_id, np.arange(1000))
        
        # Content-based filtering
        if user_id in self.user_features:
            user_vec = np.array([self.user_features[user_id]])
            item_vecs = np.array(list(self.item_features.values()))
            scores_cb = cosine_similarity(user_vec, item_vecs)[0]
            
            # Combine scores
            combined_scores = (scores_cf + scores_cb) / 2
        else:
            combined_scores = scores_cf
            
        # Return top-N recommendations
        return np.argsort(combined_scores)[-n:][::-1].tolist()
    
    async def handle_cold_start(self, user_id: int, preferences: List[str]):
        """Handle new users with content-based recommendations."""
        # Extract features from user preferences
        tfidf_matrix = self.tfidf.fit_transform(preferences)
        user_features = tfidf_matrix.mean(axis=0).tolist()[0]
        self.user_features[user_id] = user_features
        
        # Get similar items
        return self.get_recommendations(user_id, n=10)

@app.post("/recommend")
async def recommend(user_id: int, preferences: List[str] = None):
    system = HybridRecommendationSystem()
    
    # Handle cold start
    if not preferences:
        recommendations = await system.get_recommendations(user_id)
    else:
        recommendations = await system.handle_cold_start(user_id, preferences)
    
    # Store in Redis for caching
    redis_client.set(f"rec:{user_id}", json.dumps(recommendations))
    return {"recommendations": recommendations}

# Example usage
asyncio.run(HybridRecommendationSystem().update_model(
    [{"user_id": 0, "item_id": 1, "rating": 4}],
    [{"item_id": 1, "title": "Movie A", "genre": "action"}]
))

import numpy as np
from sklearn.metrics.pairwise import cosine_similarity

# Sample user-item interaction matrix (rows: users, cols: items)
ratings = np.array([
    [5, 3, 0, 1, 4],
    [4, 0, 0, 1, 2],
    [1, 1, 0, 5, 1],
    [1, 0, 0, 5, 4]
])

# Simulated item features (e.g., genre, category)
item_features = {
    0: ["action", "adventure"],
    1: ["drama", "romance"],
    2: ["comedy", "fantasy"],
    3: ["action", "sci-fi"],
    4: ["drama", "thriller"]
}

def get_user_similarity(user_id, ratings):
    """Calculate similarity between users using cosine similarity."""
    return cosine_similarity(ratings[user_id].reshape(1, -1), ratings)[0]

def get_item_similarity(item_id, ratings):
    """Calculate similarity between items."""
    return cosine_similarity(ratings.T[item_id].reshape(1, -1), ratings.T)[0]

def recommend_items(user_id, ratings, item_features):
    """Generate recommendations for a user."""
    # Collaborative filtering: find similar users
    similarities = get_user_similarity(user_id, ratings)
    similar_users = np.argsort(similarities)[-3:]  # Top 3 similar users
    
    # Get items liked by similar users but not by current user
    recommended_items = set()
    for u in similar_users:
        if u != user_id:
            for i in range(len(ratings[u])):
                if ratings[u][i] > 0 and ratings[user_id][i] == 0:
                    recommended_items.add(i)
    
    # Content-based filtering: recommend similar items
    user_likes = []
    for i in range(len(ratings[user_id])):
        if ratings[user_id][i] > 0:
            user_likes.extend(item_features[i])
    
    for item_id, features in item_features.items():
        if item_id not in recommended_items:
            common = len(set(user_likes) & set(features))
            if common > 0:
                recommended_items.add(item_id)
    
    return list(recommended_items)

# Example usage
print("Recommendations for user 0:", recommend_items(0, ratings, item_features))

def simple_chatbot():
    print("Hello! I'm a basic chatbot. Type 'bye' to exit.")
    while True:
        user_input = input("You: ").lower()
        if "hello" in user_input or "hi" in user_input:
            print("Bot: Hi there! How can I help?")
        elif "name" in user_input:
            print("Bot: I'm ChatBot. Nice to meet you!")
        elif "bye" in user_input:
            print("Bot: Goodbye! See you later.")
            break
        else:
            print("Bot: I didn't understand that.")

simple_chatbot()