Yayın Platformları için Öneri Sistemi Eğitimi

Dizi ve filmleri art arda izleme (binge-watching) kültürünün yaygınlaşmasıyla birlikte, kullanıcılar Netflix, Prime Video, Hulu ve Disney+ gibi hizmetler sayesinde içeriği hızlı bir tempoda tüketiyor. Hulu ve YouTube TV gibi yeni platformlardan bazıları, Spor, canlı konser/tur ve haber kanalları gibi etkinliklerin canlı yayınını da sunuyor. Netflix gibi bazı yayın platformları ise hâlâ canlı yayını benimsemiş değil.

Yayın platformları, kullanıcıların istedikleri zaman ve istedikleri cihazda favori dizi ve filmlerini izlemelerine daha fazla esneklik sağlar. Bu hizmetler, sundukları geniş dizi ve film yelpazesi nedeniyle daha genç ve modern kitleleri cezbedebilir. Kullanıcılar, kaçırdıkları programları uygun oldukları bir zamanda izleyebilir. Bu eğitimde, Netflix, Prime Video, Hulu ve Disney+ platformlarının film verilerini analiz edecek ve izleyicilerini anlamaya çalışacaksınız.

Veri Setini Anlama

Bu veri, Netflix, Prime Video, Hulu ve Disney+ gibi yayın platformlarında bulunan yalnızca filmlerden oluşur. Kaggle’dan buradan indirebilirsiniz.

Veri özniteliklerini ayrıntılı olarak tanımlayalım:

• ID: Her kayıt için benzersiz bir ID.
• Title: Filmin adı
• Year: Filmin çıkış yılı.
• Age: Hedef yaş grubu
• IMDb: Filmlerin IMDB puanı.
• Rotten Tomatoes: Rotten Tomatoes %
• Netflix: filmin Netflix’te bulunup bulunmadığı
• Hulu: filmin Hulu’da bulunup bulunmadığı
• Prime Video: filmin Prime Video’da bulunup bulunmadığı
• Disney+: filmin Disney+’ta bulunup bulunmadığı
• Type: Film veya TV programı
• Directors: Yönetmenin adı
• Genres: Tür
• Country: Menşe ülke
• Language: Orijinal dil
• Runtime: Filmin süresi

Gerekli modülleri içe aktaralım ve veri setini yükleyelim:

 # Import required libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.feature_extraction.text import TfidfVectorizer    
from nltk.tokenize import RegexpTokenizer
import numpy as np
from sklearn import preprocessing
from scipy.sparse import hstack
import pandas_profilingAltyapı:

# Load dataset
df = pd.read_csv("tvshow.csv")
df=df.iloc[:,1:] # removing in unnamed index columnAltyapı:

df.head()Altyapı:

# Show initial information about the dataset
df.info()
Altyapı:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 16744 entries, 0 to 16743
Data columns (total 16 columns):
 #   Column           Non-Null Count  Dtype  
---  ------           --------------  -----  
 0   ID               16744 non-null  object
 1   Title            16744 non-null  object
 2   Year             16744 non-null  int64  
 3   Age              7354 non-null   object
 4   IMDb             16173 non-null  float64
 5   Rotten Tomatoes  5158 non-null   object
 6   Netflix          16744 non-null  int64  
 7   Hulu             16744 non-null  int64  
 8   Prime Video      16744 non-null  int64  
 9   Disney+          16744 non-null  int64  
 10  Type             16744 non-null  int64  
 11  Directors        16018 non-null  object
 12  Genres           16469 non-null  object
 13  Country          16309 non-null  object
 14  Language         16145 non-null  object
 15  Runtime          16152 non-null  float64
dtypes: float64(2), int64(6), object(8)
memory usage: 2.0+ MB
Altyapı:

df.Type.unique()
Altyapı:

array([0])
Altyapı:

Eksik Değerlerle Çalışma

Bu bölümde, isnull() fonksiyonunu kullanarak eksik değerlerle çalışacaksınız. Aşağıda bir örnek görelim:

 #Finding Missing values in all columns
miss = pd.DataFrame(df.isnull().sum())
miss = miss.rename(columns={0:"miss_count"})
miss["miss_%"] = (miss.miss_count/len(df.ID))*100
missAltyapı:

Age ve Rotten tomatoes değişkenlerinde %50’den fazla eksik değer olduğu görülüyor; bu dikkat edilmesi gereken bir durum.

Şimdi eksik değerleri şu adımlarla ele alacağız:

• %50’den fazla eksik değeri olan sütunları düşürün
• IMDb, Directors, Genres, Country, Language ve Runtime sütunlarındaki NA’leri kaldırın
• İndeksi sıfırlayın
• Year sütununu object tipine dönüştürün

# Dropping values with missing % more than 50%
df.drop(['Rotten Tomatoes', 'Age'], axis = 1, inplace=True)
# Dropping Na's from the following columns
df.dropna(subset=['IMDb','Directors', 'Genres', 'Country', 'Language', 'Runtime'],inplace=True)
df.reset_index(inplace=True,drop=True)
# Converting into object type
df.Year = df.Year.astype("object")Altyapı:

df.info()Altyapı:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 15233 entries, 0 to 15232
Data columns (total 14 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   ID           15233 non-null  object
 1   Title        15233 non-null  object
 2   Year         15233 non-null  object
 3   IMDb         15233 non-null  float64
 4   Netflix      15233 non-null  int64  
 5   Hulu         15233 non-null  int64  
 6   Prime Video  15233 non-null  int64  
 7   Disney+      15233 non-null  int64  
 8   Type         15233 non-null  int64  
 9   Directors    15233 non-null  object
 10  Genres       15233 non-null  object
 11  Country      15233 non-null  object
 12  Language     15233 non-null  object
 13  Runtime      15233 non-null  float64
dtypes: float64(2), int64(5), object(7)
memory usage: 1.6+ MB
Altyapı:

Dağılım Grafikleri

Year sütununun dağılımını seaborn’un distplot() fonksiyonuyla kontrol edebilirsiniz. Film Yılı dağılım grafiğini çizelim.

#checking Distribution of years
plt.figure(figsize=(20,5))
sns.distplot(df['Year'])
plt.show()
Altyapı:

Grafik, filmlerin çıkış yılı dağılımını gösteriyor. Çoğu filmin 2000 ile 2020 yılları arasında yapıldığını yorumlayabilirsiniz. Şimdi IMDB puanı dağılım grafiğini çizelim.

# Distribution of IMDb Rating
plt.figure(figsize=(20,5))
sns.distplot(df['IMDb'])
plt.show()
Altyapı:

Yukarıdaki dağılım grafiği hafifçe çarpık. Çoğu filmin ortalama IMDB puanının 6,5 olduğunu yorumlayabilirsiniz.

Şimdi Film Süresi dağılım grafiğini çizelim.

# Distribution of runtime
sns.distplot(df['Runtime'])
plt.show()
Altyapı:

Yukarıdaki grafikten, filmlerin ortalama süresinin 80 ile 120 dakika arasında olduğunu yorumlayabilirsiniz.

Her Yayın Platformunda Film Dağılımı

Bu bölümde, platforma göre film dağılımını göreceksiniz. Önce, belirli bir yayın platformundaki film sayısını hesaplayan bir m_cnt() fonksiyonu oluşturmanız gerekir. Ardından, Pasta grafikleri kullanarak çizim yapabilir ve platformların paylarını anlayabilirsiniz.

# A function to calculate the movies in different Streaming platforms
def m_cnt(plat, count=False):
    if count==False:
        print('Platform {} Count: {}'. format(plat, df[plat].sum()))
    else:
        return df[plat].sum()
Altyapı:

# Let's see count of movies/shows of each streaming platform
m_cnt('Netflix')
m_cnt('Hulu')
m_cnt('Prime Video')
m_cnt('Disney+')
Altyapı:

Platform Netflix Count: 3152
Platform Hulu Count: 848
Platform Prime Video Count: 11289
Platform Disney+ Count: 542
Altyapı:

# Movies on each platform
lab = 'Prime Video','Netflix', 'Hulu', 'Disney'
s = [m_cnt('Prime Video', count=True),
     m_cnt('Netflix', count=True),
     m_cnt('Hulu', count=True),
     m_cnt('Disney+', count=True)]

explode = (0.1, 0.1, 0.1, 0.1)

#plotting
fig1, ax1 = plt.subplots()
ax1.pie(s,
       labels = lab,
       autopct = '%1.1f%%',
       explode = explode,
       shadow = True,
       startangle = 100)

ax1.axis = ('equal')
plt.show()
Altyapı:

Yukarıdaki grafikten, Prime Video’nun %71 payla en fazla sayıda başlığa ev sahipliği yaptığını, Netflix’in ise başlıkların %20’sini barındırdığını söyleyebilirsiniz. Disney+ ve Hulu sırasıyla %5,4 ve %3,4 ile en düşük başlık sayısına sahip.

Türe Göre Film Dağılımı

Bu bölümde, türe göre film dağılımını göreceksiniz. Önce verinizi hazırlamanız gerekir. Veri çerçevesindeki tek bir hücrede birden fazla tür bulunmasını ele almalısınız. Bunun için split(), apply() ve stack() fonksiyonlarını kullanabilirsiniz. split() fonksiyonu çoklu değerleri virgülle ayırır ve bir liste oluşturur. apply(pd.Series,1) her bir tür için birden fazla sütun oluşturur ve stack() fonksiyonu bunları tek bir sütunda istifler.

Bu üç işlemin ardından yeni Genres sütunu mevcut veri çerçevesine eklenir ve çizim yapmaya hazırsınız. value_counts() fonksiyonunu kullanarak en popüler 10 türü film sayılarıyla birlikte gösterebilir ve pandas kütüphanesinin plot() fonksiyonunu kullanabilirsiniz.

 ##split the genres by ',' & then stack it one after the other for easy analysis.
g = df['Genres'].str.split(',').apply(pd.Series, 1).stack()
g.index = g.index.droplevel(-1)
# Assign name to column
g.name = 'Genres'
# delete column
del df['Genres']
# join new column with the existing dataframe
df_genres = df.join(g)Altyapı:

# Count of movies according to genre
plt.figure(figsize=(15,5))
sns.countplot(x='Genres', data=df_genres)
plt.xticks(rotation=90)
plt.show()Altyapı:

Yukarıdaki grafikten, filmlerin büyük kısmının ortak türlerinin Drama ve Komedi olduğunu söyleyebilirsiniz.

Ülkeye Göre Film Dağılımı

Bu bölümde, ülkeye göre film dağılımını göreceksiniz. Önce verinizi hazırlamanız gerekir. Veri çerçevesindeki tek bir hücrede birden fazla ülke bulunmasını ele almalısınız. Bunun için split(), apply() ve stack() fonksiyonlarını kullanabilirsiniz. split() fonksiyonu çoklu değerleri virgülle ayırır ve bir liste oluşturur. apply(pd.Series,1) her ülke için birden fazla sütun oluşturur ve stack() fonksiyonu bunları tek bir sütunda istifler.

Bu üç işlemin ardından yeni Country sütunu mevcut veri çerçevesine eklenir ve çizim yapmaya hazırsınız. value_counts() fonksiyonunu kullanarak en çok 10 ülkeyi film sayılarıyla gösterebilir ve pandas kütüphanesinin plot() fonksiyonunu kullanabilirsiniz.

 # Split the Country by ',' & then stack it one after the other for easy analysis.
c = df['Country'].str.split(',').apply(pd.Series, 1).stack()
c.index = c.index.droplevel(-1)
# Assign name to column
c.name = 'Country'
# delete column
del df['Country']
# join new column with the existing dataframe
df_country = df.join(c)Altyapı:

# plotting top 10 country and movie count
df_country['Country'].value_counts()[:10].plot(kind='bar',figsize=(15,5))
plt.show()Altyapı:

Yukarıdaki grafik, filmlerin çoğunun Amerika Birleşik Devletleri’nde çekildiğini gösteriyor.

Dile Göre Film Dağılımı

Bu bölümde, dile göre film dağılımını göreceksiniz. Önce verinizi hazırlamanız gerekir. Veri çerçevesindeki tek bir hücrede birden fazla dil bulunmasını ele almalısınız. Bunun için split(), apply() ve stack() fonksiyonlarını kullanabilirsiniz. split() fonksiyonu çoklu değerleri virgülle ayırır ve bir liste oluşturur. apply(pd.Series,1) her dil için birden fazla sütun oluşturur ve stack() fonksiyonu bunları tek bir sütunda istifler.

Bu üç işlemin ardından yeni Language sütunu mevcut veri çerçevesine eklenir ve çizim yapmaya hazırsınız. value_counts() fonksiyonunu kullanarak en popüler 10 dili film sayılarıyla gösterebilir ve pandas kütüphanesinin plot() fonksiyonunu kullanabilirsiniz.

 # perform stacking operation on language column
l = df['Language'].str.split(',').apply(pd.Series,1).stack()
l.index = l.index.droplevel(-1)
# Assign name to column
l.name = 'Language'
# delete column
del df['Language']
# join new column with the existing dataframe
df_language = df.join(l)Altyapı:

# plotting top 10 Language and movie count
df_language['Language'].value_counts()[:10].plot(kind='bar',figsize=(15,3))
plt.show()Altyapı:

Yukarıdaki grafikten, çoğu filmin İngilizce dilinde olduğunu çıkarabilirsiniz.

Her Platforma Göre IMDB Puanı Dağılımı

Bu bölümde, platforma göre IMDB puanı dağılımını çizeceksiniz. Bu sonuçları elde etmek için melt() fonksiyonunu uygulayıp FacetGrid grafiği çizeceksiniz. melt() fonksiyonu geniş veri çerçevesini uzun formata dönüştürür. Aşağıda bir örnek görelim:

 # melting platform columns to create visualization
df2 = pd.melt(df, id_vars=["ID","Title","Year","IMDb","Type","Runtime"], var_name="platform")
df2 = df2[df2.value==1]
df2.drop(columns=["value"],axis=1,inplace=True)Altyapı:

# Distribution of IMDB rating in different platform
g = sns.FacetGrid(df2, col = "platform")
g.map(plt.hist, "IMDb")
plt.show()Altyapı:

Yukarıdaki grafik, her platformdaki ortalama IMDB puanı dağılımını gösterir.

Yaş Grubuyla Birlikte Platform Başına Çalışma Süresi

“Eksik Değerlerle Çalışma” bölümünde Age sütununu düşürmüştüm. Yaş grubuyla birlikte platform başına çalışma süresi sonuçlarını elde etmek için veriyi yeniden yükleyip melt() fonksiyonunu uygulamam gerekiyor.

# Load dataset
df = pd.read_csv("tvshow.csv")
df=df.iloc[:,1:]
df.ID = df.ID.astype("object")

# melting platform columns to create visualization
df2 = pd.melt(df, id_vars=["ID","Title","Year","Age","IMDb","Rotten Tomatoes","Type","Runtime"], var_name="platform")
df2 = df2[df2.value==1]
df2.drop(columns=["value"],axis=1,inplace=True)
Altyapı:

Veri setini tekrar yükleyip melting işlemini yaptıktan sonra, farklı yaş grupları için çalışma süresi ve yayın platformu grafiğini üretme zamanı.

# Total of runtime in different platform
ax = sns.barplot(x="platform", y="Runtime",hue="Age", estimator=sum, data=df2)
Altyapı:

Yukarıdaki grafik, 18+ yaş grubu kullanıcılarının Prime Video’daki toplam çalışma süresinin diğer tüm platformlara kıyasla çok daha yüksek olduğunu gösteriyor. Prime Video’nun içeriğinin büyük ölçüde 18+ yaş grubuna odaklandığını yorumlayabilirsiniz.

Bir Öneri Sistemi Oluşturma

Son birkaç yılda YouTube, Walmart, Netflix ve benzeri birçok web tabanlı hizmetin sıçramasıyla, öneri sistemleri sektörde büyük bir etki yarattı. Ürün/hizmet önermekten, çevrimiçi reklam temelli gelirle şirket değerini artırmaya ve kullanıcıların ilgisi ve tercihini eşleştirerek satın alma davranışına yönlendirmeye kadar, öneri sistemleri günlük web yolculuklarımızda vazgeçilmezdir.

Genel olarak, bunlar son kullanıcılara ihtiyaç ve isteklerine uygun ürün/hizmet önermeye odaklanan matematik temelli çerçevelerdir. Örneğin izlenecek filmler, okunacak makaleler, satın alınacak ürünler, dinlenecek müzikler veya etki alanına bağlı herhangi bir şey. Temelde üç yöntemle Öneri Sistemleri oluşturulur:

1. İçerik Tabanlı Yöntemler: Öğelerin özellik setine dayalı olarak kullanıcılar veya kullanıcının etkileşimde bulunduğu öğeler için bir model tanımlar ve kullanıcılara benzer diğer öğeleri önerir.
2. Ortak Filtreleme Yöntemleri: Kullanıcılar ve öğeler arası etkileşim benzerlik puanı ya da Kullanıcı-Kullanıcı benzerlik puanı tanımlar ve bunu öğe önerimi için kullanır.
3. Hibrit Yöntemler: Daha iyi sonuç için hem içerik hem de ortak filtreleme yöntemlerini kullanır.

Öneri sistemi için önce veri setini önişlemeden geçirelim. Önce eksik değerlere bakın:

# Reading Data Again
df = pd.read_csv("tvshow.csv")
df=df.iloc[:,1:]
Altyapı:

#Finding Missing values in all columns
miss = pd.DataFrame(df.isnull().sum())
miss = miss.rename(columns={0:"miss_count"})
miss["miss_%"] = (miss.miss_count/len(df.ID))*100
miss
Altyapı:

#Dropping values with missing % more than 50%
df.drop(['Rotten Tomatoes', 'Age'], axis = 1, inplace=True)
# Dropping Na's from the following columns
df.dropna(subset=['IMDb','Directors', 'Genres', 'Country', 'Language', 'Runtime'],inplace=True)
df.reset_index(inplace=True,drop=True)
# converting into object type
df.ID = df.ID.astype("object")
df.Year = df.Year.astype("object")
Altyapı:

Kosinüs benzerliğine dayalı iki öneri sistemi oluşturacaksınız.

1. Using only the numerical variable
2. Using both numerical and categorical variable
Altyapı:

Yalnızca Sayısal Sütunları Kullanma

Adım 1: Sayısal değişkeni seçin

ndf = df.select_dtypes(include=['float64',"int64"])
Altyapı:

Adım 2: Model karmaşıklığını ve eğitim süresini azaltmak için sayısal değişkeni min-max ölçekleyiciyle ölçekleme

#importing minmax scaler
from sklearn import preprocessing

# Create MinMaxScaler Object
scaler = preprocessing.MinMaxScaler(feature_range=(0, 1))

# Create dataframe after transformation
ndfmx = pd.DataFrame((scaler.fit_transform(ndf)))

# assign column names
ndfmx.columns=ndf.columns

# Show initial 5 records
ndfmx.head()
Altyapı:

Adım 3: Kosinüs benzerliği kullanarak benzerlik puanını hesaplayın

Şimdi kosinüs benzerliğini kullanarak benzerlik puanını hesaplayacaksınız.

# Import cosine similarity
from sklearn.metrics.pairwise import cosine_similarity

# Compute the cosine similarity
sig = cosine_similarity(ndfmx, ndfmx)

# Reverse mapping of indices and movie titles
indices = pd.Series(df.index, index=df['Title']).drop_duplicates()
Altyapı:

indices.head()
Altyapı:

Adım 4: Benzerlik puanına göre öneri almak için bir fonksiyon yazma

• Fonksiyon iki argüman alır: film adı ve benzerlik puanları. İndeks serimizdeki original_titles indeksine karşılık gelen başlığın indeksini arar.
• Tüm filmlerin ikili benzerlik puanlarını alın.
• Benzerlik puanlarını azalan sırada sıralayıp listeye dönüştürün.
• İlk 10 filmin puanlarını ve indekslerini alın ve veri çerçevemizden bu filmlerin başlıklarını döndürün.

def give_rec(title, sig=sig):

    # Get the index corresponding to original_title
    idx = indices[title]

    # Get the pairwise similarity scores
    sig_scores = list(enumerate(sig[idx]))

    # Sort the movies
    sig_scores = sorted(sig_scores, key=lambda x: x[1], reverse=True)

    # Scores of the 10 most similar movies
    sig_scores = sig_scores[1:11]

    # Movie indices
    movie_indices = [i[0] for i in sig_scores]

    # Top 10 most similar movies
    return df['Title'].iloc[movie_indices]
Altyapı:

# Execute get_rec() function for getting recommendation
give_rec("The Matrix",sig = sig)
Altyapı:

Burada önerilen filmler pek tatmin edici değil. Bu zayıf sonucun nedeni, yalnızca film puanları, film süreleri ve platform değişkenlerini kullanmanız. Tür, yönetmenler ve ülke gibi diğer bilgileri kullanarak bunu iyileştirebilirsiniz.

Sayısal ve Metinsel Sütunları Kullanma

Önceki öneri sistemimiz çalıştı ancak öneriler yeterince iyi değildi; bu nedenle sonuçları iyileştirmek için yeni ve daha iyi bir yaklaşım deneyeceksiniz.

df.head()
Altyapı:

Adım 1:

Metinsel sütunları tek bir sütunda birleştirip, belirteçleyici (tokenizer) ve TF-IDF Vektörleştirici kullanarak tüm kelimelerin TF-IDF puanlarından oluşan seyrek bir matris oluşturacaksınız. Sonra sayısal değişkenleri seçip ölçekleyecek ve bu seyrek matrise ekleyeceksiniz. Önişleme için şu adımları uygulamanız gerekir:

• Tüm object veri tiplerini seçip bir listede saklama.
• ID ve Title sütunlarını kaldırma.
• Tüm metin/object sütunlarını virgülle birleştirerek tek bir sütun oluşturma.
• Verimizden istenmeyen öğeleri (semboller ve sayılar gibi) kaldırmak için bir belirteçleyici oluşturma.
• Metinden TfidfVector’e dönüştürme Ardından sayısal sütunlar önişlemesi yapılacak
• Sayısal değişkenleri bir DataFrame’e seçme
• Sayısal değişkenleri min-max ölçekleyiciyle (0,1) aralığında ölçekleme
• hstack fonksiyonunu kullanarak (hstack, seyrek matrise yatay diziler eklemek için kullanılır) sayısal değişkenleri TF-IDF vektörlerinin seyrek matrisine ekleme.

#the function performs all the important preprocessing steps
def preprocess(df):
    #combining all text columns
    # Selecting all object data type and storing them in list
    s = list(df.select_dtypes(include=['object']).columns)
    # Removing ID and Title column
    s.remove("Title")
    s.remove("ID")
    # Joining all text/object columns using commas into a single column
    df['all_text']= df[s].apply(lambda x: ','.join(x.dropna().astype(str)),axis=1)

    # Creating a tokenizer to remove unwanted elements from our data like symbols and numbers
    token = RegexpTokenizer(r'[a-zA-Z]+')

    # Converting TfidfVector from the text
    cv = TfidfVectorizer(lowercase=True,stop_words='english',ngram_range = (1,1),tokenizer = token.tokenize)
    text_counts= cv.fit_transform(df['all_text'])

    # Aselecting numerical variables
    ndf = df.select_dtypes(include=['float64',"int64"])

    # Scaling Numerical variables
    scaler = preprocessing.MinMaxScaler(feature_range=(0, 1))

    # Applying scaler on our data and converting i into a data frame
    ndfmx = pd.DataFrame((scaler.fit_transform(ndf)))
    ndfmx.columns=ndf.columns    

    # Adding our adding numerical variables in the TF-IDF vector
    IMDb = ndfmx.IMDb.values[:, None]
    X_train_dtm = hstack((text_counts, IMDb))
    Netflix = ndfmx.Netflix.values[:, None]
    X_train_dtm = hstack((X_train_dtm, Netflix))
    Hulu = ndfmx.Hulu.values[:, None]
    X_train_dtm = hstack((X_train_dtm, Hulu))
    Prime = ndfmx["Prime Video"].values[:, None]
    X_train_dtm = hstack((X_train_dtm, Prime))
    Disney = ndfmx["Disney+"].values[:, None]
    X_train_dtm = hstack((X_train_dtm, Disney))
    Runtime = ndfmx.Runtime.values[:, None]
    X_train_dtm = hstack((X_train_dtm, Runtime))
    return X_train_dtm
Altyapı:

Adım 2: Fonksiyonu verimize uygulayıp seyrek bir matris oluşturma

# Preprocessing data
mat =preprocess(df)
mat.shape
Altyapı:

Adım 3: Benzerlik puanını hesaplamak için tekrar Kosinüs Benzerliği uygulama

# using cosine similarity
from sklearn.metrics.pairwise import cosine_similarity

# Compute the sigmoid kernel
sig2 = cosine_similarity(mat, mat)

# Reverse mapping of indices and movie titles
indices = pd.Series(df.index, index=df['Title']).drop_duplicates()
Altyapı:

Adım 4: Geliştirilmiş sistemimizden öneri alma

give_rec("The Matrix",sig=sig2)
Altyapı:

Bu kez öneri sistemi önceki sisteme göre çok daha iyi çalışıyor; bu da açıklama metni gibi daha ilgili veriler ekleyerek içerik tabanlı bir öneri sisteminin önemli ölçüde iyileştirilebileceğini gösteriyor.

Sonuç

Tebrikler, bu eğitimin sonuna ulaştınız!

Bu eğitimde, yayın platformu film veri seti üzerinde keşifsel bir analiz gerçekleştirdiniz. Eksik değerleri, tekil dağılım grafiklerini ve her yayın platformundaki film dağılımını incelediniz. Ayrıca tür, ülke, dil, IMDB puanları ve film süresi hakkında içgörüler keşfettiniz. Son olarak, Python’da nasıl öneri sistemi kurulacağını da gördünüz.

DataCamp’in Python’da Öneri Sistemleri eğitimine göz atın.