AI Öneri Sistemi: Kişiselleştirilmiş Öneriler

# User-based Collaborative Filtering (Scikit-learn)
import numpy as np
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity

# Kullanıcı-Ürün matrisi (rating: 1-5, 0: görülmemiş)
user_item_matrix = pd.DataFrame({
    'Laptop_A': [5, 4, 0, 0, 2],
    'Laptop_B': [4, 0, 0, 5, 3],
    'Mouse_C': [0, 3, 4, 4, 0],
    'Keyboard_D': [0, 0, 5, 4, 0],
    'Monitor_E': [2, 0, 3, 0, 4]
}, index=['User_1', 'User_2', 'User_3', 'User_4', 'User_5'])

# Kullanıcılar arası benzerlik hesapla (cosine similarity)
user_similarity = cosine_similarity(user_item_matrix.fillna(0))
user_similarity_df = pd.DataFrame(
    user_similarity,
    index=user_item_matrix.index,
    columns=user_item_matrix.index
)

print(user_similarity_df)
#           User_1  User_2  User_3  User_4  User_5
# User_1    1.000   0.894   0.267   0.387   0.678
# User_2    0.894   1.000   0.298   0.433   0.601
# ...

# User_1 için öneri
def recommend_for_user(user_id, n_recommendations=3):
    # 1. Benzer kullanıcıları bul
    similar_users = user_similarity_df[user_id].sort_values(ascending=False)[1:4]  # Top 3

    # 2. Benzer kullanıcıların beğendiği ama user_id'nin görmediği ürünleri bul
    recommendations = {}

    for similar_user, similarity_score in similar_users.items():
        # Bu kullanıcının beğendiği ürünler
        liked_items = user_item_matrix.loc[similar_user][user_item_matrix.loc[similar_user] >= 4]

        for item, rating in liked_items.items():
            # User_1 bu ürünü daha önce görmediyse
            if user_item_matrix.loc[user_id, item] == 0:
                if item not in recommendations:
                    recommendations[item] = 0
                # Ağırlıklı puan (benzerlik × rating)
                recommendations[item] += similarity_score * rating

    # Skorlara göre sırala
    sorted_recommendations = sorted(recommendations.items(), key=lambda x: x[1], reverse=True)

    return sorted_recommendations[:n_recommendations]

# User_1 için öneriler
print(recommend_for_user('User_1'))
# [('Keyboard_D', 4.23), ('Mouse_C', 3.87), ('Monitor_E', 2.15)]

# Content-Based Filtering (ürün özelliklerine göre)
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import linear_kernel

# Ürün verileri
products = pd.DataFrame({
    'product_id': ['P1', 'P2', 'P3', 'P4', 'P5'],
    'name': ['ASUS Laptop', 'Dell Laptop', 'Logitech Mouse', 'HP Monitor', 'Apple MacBook'],
    'description': [
        'ASUS gaming laptop 15 inch RTX 4060 Intel i7 Windows',
        'Dell business laptop 14 inch integrated graphics Intel i5 Windows',
        'Logitech wireless mouse ergonomic gaming RGB',
        'HP 27 inch 4K monitor IPS panel USB-C',
        'Apple MacBook Air M2 chip 13 inch macOS lightweight'
    ]
})

# TF-IDF ile metin vektörleştirme
tfidf = TfidfVectorizer(stop_words='english')
tfidf_matrix = tfidf.fit_transform(products['description'])

# Ürünler arası benzerlik (cosine similarity)
cosine_sim = linear_kernel(tfidf_matrix, tfidf_matrix)

print(cosine_sim)
# P1-P2: 0.42 (her ikisi de laptop, benzer)
# P1-P3: 0.15 (laptop vs mouse, az benzer)
# P1-P5: 0.31 (laptop, orta benzer)

# Ürün önerisi
def recommend_similar_products(product_id, n=3):
    idx = products[products['product_id'] == product_id].index[0]

    # Benzerlik skorları
    sim_scores = list(enumerate(cosine_sim[idx]))

    # Kendi hariç sırala
    sim_scores = sorted(sim_scores, key=lambda x: x[1], reverse=True)[1:n+1]

    # Ürün ID'lerini döndür
    product_indices = [i[0] for i in sim_scores]

    return products.iloc[product_indices][['product_id', 'name']]

# ASUS Laptop için benzer ürünler
print(recommend_similar_products('P1'))
#   product_id            name
# 1         P2     Dell Laptop
# 4         P5  Apple MacBook
# 3         P4      HP Monitor

# Singular Value Decomposition (SVD) ile öneri
from scipy.sparse.linalg import svds

# User-item matrisi (0: görülmemiş)
R = user_item_matrix.fillna(0).values

# SVD uygula (k=2: 2 latent faktör)
U, sigma, Vt = svds(R, k=2)

# Sigma'yı diagonal matrise çevir
sigma = np.diag(sigma)

# Tahmin matrisi
predicted_ratings = np.dot(np.dot(U, sigma), Vt)

# DataFrame'e çevir
predicted_df = pd.DataFrame(
    predicted_ratings,
    columns=user_item_matrix.columns,
    index=user_item_matrix.index
)

print(predicted_df)
#         Laptop_A  Laptop_B  Mouse_C  Keyboard_D  Monitor_E
# User_1     4.87      4.23     2.34        3.12        2.56
# User_2     3.98      3.45     2.89        2.67        1.98
# ...

# User_1 için en yüksek tahminli ürünleri öner (daha önce görmediklerinden)
def recommend_svd(user_id, n=3):
    user_row = predicted_df.loc[user_id]
    original_row = user_item_matrix.loc[user_id]

    # Daha önce görülmemiş ürünler
    unseen = original_row[original_row == 0].index

    # Tahmin skorlarına göre sırala
    recommendations = user_row[unseen].sort_values(ascending=False).head(n)

    return recommendations

print(recommend_svd('User_1'))
# Keyboard_D    3.12
# Mouse_C       2.34
# Monitor_E     2.56

# TensorFlow/Keras ile Neural Collaborative Filtering
import tensorflow as tf
from tensorflow.keras import layers, Model

# Model mimarisi
class RecommenderNet(Model):
    def __init__(self, num_users, num_items, embedding_size=50):
        super(RecommenderNet, self).__init__()

        # User embedding
        self.user_embedding = layers.Embedding(
            num_users,
            embedding_size,
            embeddings_initializer='he_normal',
            embeddings_regularizer=tf.keras.regularizers.l2(1e-6)
        )
        self.user_bias = layers.Embedding(num_users, 1)

        # Item embedding
        self.item_embedding = layers.Embedding(
            num_items,
            embedding_size,
            embeddings_initializer='he_normal',
            embeddings_regularizer=tf.keras.regularizers.l2(1e-6)
        )
        self.item_bias = layers.Embedding(num_items, 1)

    def call(self, inputs):
        user_vector = self.user_embedding(inputs[:, 0])
        user_bias = self.user_bias(inputs[:, 0])
        item_vector = self.item_embedding(inputs[:, 1])
        item_bias = self.item_bias(inputs[:, 1])

        # Dot product + biases
        dot_user_item = tf.reduce_sum(user_vector * item_vector, axis=1, keepdims=True)
        rating = dot_user_item + user_bias + item_bias

        return tf.nn.sigmoid(rating) * 5  # 0-5 arası rating

# Model oluştur
model = RecommenderNet(num_users=1000, num_items=5000, embedding_size=50)

model.compile(
    loss=tf.keras.losses.MeanSquaredError(),
    optimizer=tf.keras.optimizers.Adam(learning_rate=0.001)
)

# Eğitim verisi: [user_id, item_id] → rating
# train_data = [[123, 456], [124, 457], ...]  # user-item pairs
# train_labels = [4.5, 3.0, ...]  # ratings

# model.fit(train_data, train_labels, epochs=10, batch_size=64)

# Tahmin
user_id = 123
item_id = 789
predicted_rating = model.predict([[user_id, item_id]])[0][0]
print(f"Predicted rating: {predicted_rating:.2f}/5.0")

# E-ticaret önerisi: Hybrid yaklaşım
class HybridRecommender:
    def __init__(self):
        self.collaborative_model = None  # Collaborative filtering
        self.content_model = None  # Content-based
        self.trending_products = []  # Popüler ürünler

    def get_recommendations(self, user_id, n=10):
        recommendations = []

        # 1. Collaborative filtering (50% ağırlık)
        if self.collaborative_model:
            collab_recs = self.collaborative_model.recommend(user_id, n=15)
            recommendations.extend([(item, score * 0.5, 'collaborative') for item, score in collab_recs])

        # 2. Content-based (30% ağırlık)
        user_history = get_user_purchase_history(user_id)
        if user_history:
            for product in user_history[-3:]:  # Son 3 ürün
                similar = self.content_model.find_similar(product, n=5)
                recommendations.extend([(item, score * 0.3, 'content') for item, score in similar])

        # 3. Trending/Popular (20% ağırlık - cold start için)
        if len(recommendations) < 5:
            recommendations.extend([(item, 0.2, 'trending') for item in self.trending_products[:5]])

        # 4. Business rules (filtreler)
        recommendations = self.apply_business_rules(user_id, recommendations)

        # 5. Skor toplama ve sıralama
        from collections import defaultdict
        final_scores = defaultdict(float)

        for item, score, source in recommendations:
            final_scores[item] += score

        # En yüksek skorlu N ürün
        sorted_recs = sorted(final_scores.items(), key=lambda x: x[1], reverse=True)

        return sorted_recs[:n]

    def apply_business_rules(self, user_id, recommendations):
        """İş kuralları uygula"""
        filtered = []

        for item, score, source in recommendations:
            # Stokta var mı?
            if not is_in_stock(item):
                continue

            # Kullanıcı daha önce aldı mı?
            if user_purchased_before(user_id, item):
                continue

            # Kategori limiti (aynı kategoriden max 3 ürün)
            category_count = sum(1 for i, _, _ in filtered if get_category(i) == get_category(item))
            if category_count >= 3:
                continue

            filtered.append((item, score, source))

        return filtered

# Kullanım
recommender = HybridRecommender()
recommendations = recommender.get_recommendations(user_id=12345, n=10)

for product_id, score in recommendations:
    print(f"Ürün: {product_id}, Skor: {score:.2f}")