Tutorial: Aanbevelingssysteem voor streamingplatforms

Door de nieuwe cultuur van bingewatchen van tv-series en films, verbruiken gebruikers in hoog tempo content via beschikbare diensten zoals Netflix, Prime Video, Hulu en Disney+. Sommige van deze nieuwe platforms, zoals Hulu en YouTube TV, bieden ook live streams aan van sport, liveconcerten/tours en nieuwszenders. Livestreaming is nog niet omarmd door sommige streamingplatforms, zoals Netflix.

Streamingplatforms geven gebruikers meer flexibiliteit om hun favoriete series en films te kijken, op elk moment en op elk apparaat. Deze diensten kunnen meer jonge en moderne consumenten aantrekken dankzij de grote variëteit aan tv- en filmcontent. Het stelt hen in staat om gemiste programma’s te bekijken wanneer het hen uitkomt. In deze tutorial analyseer je filmdatasets van de streamingplatforms Netflix, Prime Video, Hulu en Disney+ en probeer je hun kijkers beter te begrijpen.

De dataset begrijpen

Deze data bevat uitsluitend films die beschikbaar zijn op streamingplatforms zoals Netflix, Prime Video, Hulu en Disney+. Je kunt de dataset downloaden van Kaggle hier.

Laten we de data-attributen in detail beschrijven:

• ID: Een unieke ID voor elk record.
• Title: De naam van de film
• Year: Het releasejaar van de film.
• Age: de doelgroep (leeftijdsgroep)
• IMDb: IMDb-score van films.
• Rotten Tomatoes: Rotten Tomatoes %
• Netflix: of de film op Netflix staat
• Hulu: of de film op Hulu staat
• Prime Video: of de film op Prime Video staat
• Disney+: of de film op Disney+ staat
• Type: Film of tv-serie
• Directors: Naam van de regisseur
• Genres: Type genre
• Country: Land van herkomst
• Language: Taal van herkomst
• Runtime: Speelduur van de film

Laten we de benodigde modules importeren en de dataset laden:

 # 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_profiling

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

df.head()

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

<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

df.Type.unique()

array([0])

Werken met missende waarden

In deze sectie ga je aan de slag met missende waarden met de functie isnull(). Zie het onderstaande voorbeeld:

 #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

Je ziet dat de variabelen Age en Rotten Tomatoes meer dan 50% missende waarden hebben, wat zorgwekkend is.

We gaan nu de missende waarden als volgt aanpakken:

• Kolommen verwijderen met meer dan 50% missende waarden
• NA verwijderen uit de kolommen IMDb, Directors, Genres, Country, Language en Runtime
• Index resetten
• Kolom Year omzetten naar object

# 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")

df.info()

<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

Verdelingsplots

Je kunt de verdeling van de kolom Year bekijken met de distplot()-functie van seaborn. Laten we de verdelingsplot van het filmjaar maken.

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

De grafiek laat de verdeling van de jaren van herkomst van films zien. Je kunt concluderen dat de meeste films zijn gemaakt tussen 2000 en 2020. Laten we nu de verdelingsplot van de IMDb-score maken.

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

De bovenstaande verdelingsplot is licht scheef. Je kunt afleiden dat het gemiddelde IMDb-cijfer van de meeste films 6,5 is.

Laten we de verdelingsplot van de speelduur maken.

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

Uit de bovenstaande grafiek kun je afleiden dat de gemiddelde speelduur van films tussen 80 en 120 minuten ligt.

Verdeling van films per streamingplatform

In deze sectie bekijk je de filmverdeling per streamingplatform. Eerst maak je een functie m_cnt() die films telt voor een gegeven streamingplatform. Daarna kun je cirkeldiagrammen plotten en de aandelen van de platforms begrijpen.

# 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()

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

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

# 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()

Uit de bovenstaande grafiek kun je opmaken dat Prime Video het grootste aantal titels host met een aandeel van 71%, en Netflix 20% van de titels host. Disney+ en Hulu hosten de minste titels, respectievelijk 5,4% en 3,4%.

Filmverdeling per genre

In deze sectie bekijk je de filmverdeling per genre. Eerst moet je je data voorbereiden. Je moet omgaan met meerdere genres die in één cel van de dataframe staan. Daarvoor kun je de functies split(), apply() en stack() gebruiken. De functie split() splitst meerdere waarden op komma’s en maakt een lijst. Met apply(pd.Series,1) maak je meerdere kolommen voor elk genre en met de functie stack() stapel je ze in één kolom.

Na deze drie bewerkingen wordt een nieuwe kolom Genres toegevoegd aan de bestaande dataframe en ben je klaar om te plotten. Je kunt de top 10 genres met hun aantal films tonen met de functie value_counts() en de functie plot() van de pandas-bibliotheek gebruiken.

 ##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)

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

Uit de bovenstaande plot kun je afleiden dat de meeste films het genre Drama en Comedy gemeen hebben.

Filmverdeling per land

In deze sectie bekijk je de filmverdeling per land. Eerst moet je je data voorbereiden. Je moet omgaan met meerdere landen die in één cel van de dataframe staan. Daarvoor kun je de functies split(), apply() en stack() gebruiken. De functie split() splitst meerdere waarden op komma’s en maakt een lijst. Met apply(pd.Series,1) maak je meerdere kolommen voor elk land en met de functie stack() stapel je ze in één kolom.

Na deze drie bewerkingen wordt een nieuwe kolom Country toegevoegd aan de bestaande dataframe en ben je klaar om te plotten. Je kunt de top 10 landen met hun aantal films tonen met de functie value_counts() en de functie plot() van de pandas-bibliotheek gebruiken.

 # 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)

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

De bovenstaande grafiek laat zien dat het merendeel van de films in de Verenigde Staten is gemaakt.

Filmverdeling per taal

In deze sectie bekijk je de filmverdeling per taal. Eerst moet je je data voorbereiden. Je moet omgaan met meerdere talen die in één cel van de dataframe staan. Daarvoor kun je de functies split(), apply() en stack() gebruiken. De functie split() splitst meerdere waarden op komma’s en maakt een lijst. Met apply(pd.Series,1) maak je meerdere kolommen voor elke taal en met de functie stack() stapel je ze in één kolom.

Na deze drie bewerkingen wordt een nieuwe kolom Language toegevoegd aan de bestaande dataframe en ben je klaar om te plotten. Je kunt de top 10 talen met hun aantal films tonen met de functie value_counts() en de functie plot() van de pandas-bibliotheek gebruiken.

 # 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)

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

Uit de bovenstaande plot kun je concluderen dat de meerderheid van de films in het Engels is.

Verdeling van IMDb-scores per platform

In deze sectie plot je de platformspecifieke verdeling van IMDb-scores. Om deze resultaten te krijgen, moet je de functie melt() toepassen en een FacetGrid-plot maken. De functie melt() zet een brede dataframe om naar een lange dataframe. Zie het onderstaande voorbeeld:

 # 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)

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

De bovenstaande plot toont de gemiddelde verdeling van IMDb-scores op elk platform.

Speelduur per platform, uitgesplitst naar leeftijdsgroep

In de sectie "Werken met missende waarden" heb ik de kolom Age verwijderd. Om resultaten voor Speelduur per platform uitgesplitst naar leeftijdsgroep te krijgen, moet ik de data opnieuw laden en de functie melt() toepassen.

# 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)

Nadat de dataset opnieuw is geladen en gemelt, is het tijd om een plot te genereren van speelduur versus streamingplatform voor verschillende leeftijdsgroepen.

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

De bovenstaande plot laat zien dat de totale speelduur op Prime Video voor gebruikers in de leeftijdsgroep 18+ veel hoger is dan op welke ander platform dan ook. Je kunt concluderen dat het merendeel van de content op Prime Video is gericht op de 18+-leeftijdsgroep.

Een aanbevelingssysteem bouwen

De afgelopen jaren hebben aanbevelingssystemen, met de opkomst van YouTube, Walmart, Netflix en vele andere webgebaseerde diensten, een enorme impact gehad op de industrie. Van het suggereren van producten/diensten tot het vergroten van de bedrijfswaarde via online advertentiemonetisatie en het matchen van de relevantie en voorkeuren van de gebruiker om hen te laten kopen: aanbevelingssystemen zijn onmisbaar in onze dagelijkse zoektochten op het web.

Over het algemeen zijn dit wiskundig georiënteerde raamwerken die zich richten op het aanbevelen van producten/diensten aan eindgebruikers die relevant zijn voor hun behoeften en wensen. Bijvoorbeeld: films om te kijken, artikelen om te lezen, producten om te kopen, muziek om naar te luisteren, of wat dan ook afhankelijk van het domein. Er zijn grofweg drie methoden om een aanbevelingssysteem te bouwen:

1. Contentgebaseerde methoden: Definieer een model voor gebruikers of items waarmee is geïnteracteerd op basis van de feature-set van items, en raad vergelijkbare items aan aan gebruikers.
2. Collaborative filtering-methoden: Definieer een model voor gelijkenisscores tussen gebruikers en items of tussen gebruikers onderling, gebruikt voor itemaanbeveling.
3. Hybride methoden: Gebruik zowel content- als collaboratieve methoden om een beter resultaat te bereiken.

Laten we eerst de dataset preprocessen voor het aanbevelingssysteem. Controleer eerst de missende waarden:

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

#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

#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")

Je bouwt twee aanbevelingssystemen op basis van cosinusgelijkenis.

1. Alleen met de numerieke variabele
2. Met zowel numerieke als categorische variabelen

Alleen de numerieke kolom gebruiken

Stap 1: Selecteer de numerieke variabele

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

Stap 2: Schaal de numerieke variabele met een min-max-scaler om modelcomplexiteit en traintijd te verminderen

#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()

Stap 3: Bereken gelijkenisscore met cosinusgelijkenis

Nu bereken je de gelijkenisscore met cosinusgelijkenis.

# 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()

indices.head()

Stap 4: Schrijf een functie om aanbevelingen te krijgen op basis van de gelijkenisscore

• De functie neemt twee argumenten: de filmtitel en de gelijkenisscores. Hij zoekt de index van de titel die overeenkomt met de index original_titles in onze reeks indices.
• Haal de paargewijze gelijkenisscores op van alle films.
• Sorteer de gelijkenisscores in aflopende volgorde en zet ze om in een lijst.
• Haal de top 10 filmscores en indices op en retourneer de titels van de top 10 films uit onze dataframe.

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]

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

Hier zijn de aanbevolen films niet je van het. De reden voor dit matige resultaat is dat je alleen filmbeoordelingen, speelduur en platformvariabelen gebruikt. Je kunt dit verbeteren door andere informatie te gebruiken, zoals genre, regisseurs en land.

Numerieke en tekstuele kolommen gebruiken

Omdat ons vorige aanbevelingssysteem wel werkte maar de aanbevelingen niet optimaal waren, probeer je nu een nieuwe, betere aanpak om de resultaten te verbeteren.

df.head()

Stap 1:

Je voegt tekstuele kolommen samen in één kolom en gebruikt vervolgens een tokenizer en TF-IDF Vectorizer om een sparse matrix te maken met alle TF-IDF-scores van woorden. Daarna selecteer en schaal je de numerieke variabelen en voeg je die toe aan de sparse matrix. Je voert de volgende stappen uit voor preprocessing:

• Alle object-datatypen selecteren en in een lijst opslaan.
• Kolommen ID en Title verwijderen.
• Alle tekst/objectkolommen met komma’s samenvoegen tot één kolom.
• Een tokenizer maken om ongewenste elementen zoals symbolen en cijfers uit onze data te verwijderen.
• De tekst omzetten naar TfidfVector. Daarna doen we de preprocessing van de numerieke kolommen
• Numerieke variabelen selecteren in een dataframe
• Numerieke variabelen schalen met min-max-scaler (bereik 0,1)
• Numerieke variabelen toevoegen aan de TF-IDF-sparse matrix met de hstack-functie (hstack wordt gebruikt om horizontale arrays toe te voegen aan een sparse matrix).

#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

Stap 2: De functie toepassen op onze data en een sparse matrix maken

# Preprocessing data
mat =preprocess(df)
mat.shape

Stap 3: Opnieuw cosinusgelijkenis toepassen om de gelijkenisscore te berekenen

# 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()

Stap 4: Een aanbeveling krijgen van ons verbeterde systeem

give_rec("The Matrix",sig=sig2)

Dit keer werkt het aanbevelingssysteem aanzienlijk beter dan het oudere systeem, wat laat zien dat een contentgebaseerd aanbevelingssysteem sterk kan verbeteren door meer relevante data toe te voegen, zoals beschrijvingstekst.

Conclusie

Gefeliciteerd, je bent aan het einde van deze tutorial gekomen!

In deze tutorial heb je een verkennende analyse uitgevoerd op de filmdataset van streamingplatforms. Je hebt missende waarden onderzocht, individuele verdelingsplots gemaakt en de verdeling van films per streamingplatform bekeken. Je hebt ook inzichten gevonden over genre, land, taal, IMDb-scores en speelduur. Tot slot heb je gezien hoe je in Python een aanbevelingssysteem bouwt.

Bekijk de DataCamp-tutorial Recommender Systems in Python.