Technische Hintergründe zum TikTok-Algorithmus
Dieses Arbeitsblatt bietet einen tieferen Einblick in die technischen Aspekte des TikTok-Algorithmus und richtet sich an Schülerinnen und Schüler mit Interesse an Informatik, Datenanalyse und KI. Du erfährst, wie der Algorithmus implementiert wird, welche Datenstrukturen er nutzt und wie Empfehlungen auf mathematischer Ebene funktionieren.
Der tatsächliche TikTok-Algorithmus ist wesentlich komplexer als hier dargestellt und ein gut gehütetes Geschäftsgeheimnis. Dieses Material basiert auf allgemeinen Prinzipien moderner Empfehlungsalgorithmen, öffentlichen Forschungspapieren und offiziellen Informationen von ByteDance (der Firma hinter TikTok). Die Beispiele sind vereinfacht, um die Grundkonzepte verständlich zu vermitteln.
TikTok verwendet ein komplexes System aus mehreren Algorithmen, die zusammenarbeiten, um den "For You"-Feed zu erstellen. Die Hauptkomponenten sind:
Der Algorithmus sammelt und verarbeitet verschiedene Arten von Daten:
Diese Features werden dann in numerische Vektoren umgewandelt, die der Algorithmus verarbeiten kann.
Bevor das Hauptranking stattfindet, reduziert TikTok den Pool potenzieller Videos:
Dies reduziert Millionen potenzieller Videos auf Tausende von Kandidaten, die dann genauer bewertet werden.
Das Herzstück des TikTok-Algorithmus ist das Ranking-System:
Das Ergebnis ist ein numerischer Score für jedes Kandidatenvideo, der dessen Relevanz für den spezifischen Nutzer angibt.
Der TikTok-Algorithmus lernt ständig aus Nutzeraktionen:
Dieser Feedback-Loop ist der Grund, warum der TikTok-Algorithmus so schnell lernt und sich an Nutzerinteressen anpasst.
Bei der Implementierung eines solchen Algorithmus gibt es zahlreiche technische Herausforderungen:
Eine der grundlegenden Techniken hinter modernen Empfehlungssystemen wie TikTok ist die Darstellung von Nutzern und Inhalten als Vektoren im mathematischen Raum. Diese "Embeddings" sind mehrdimensionale numerische Darstellungen, die Ähnlichkeiten und Beziehungen erfassen.
Jeder TikTok-Nutzer wird als Vektor mit hunderten oder tausenden Dimensionen repräsentiert. Dieser Vektor enthält Informationen über:
User = [0.2, 0.8, 0.1, 0.7, 0.4, ...]
Ein vereinfachtes Beispiel eines User-Vektors
Auch jedes Video wird als Vektor dargestellt, der verschiedene Eigenschaften des Inhalts repräsentiert:
Video = [0.5, 0.3, 0.9, 0.2, 0.6, ...]
Ein vereinfachtes Beispiel eines Video-Vektors
Die Grundidee des TikTok-Algorithmus basiert auf der Berechnung von Ähnlichkeiten zwischen Nutzern und Videos im Vektorraum. Gängige Methoden zur Ähnlichkeitsberechnung sind:
Berechnet den Kosinus des Winkels zwischen zwei Vektoren. Je ähnlicher die Vektoren, desto kleiner der Winkel und desto näher ist der Kosinuswert an 1.
similarity = cos(θ) = (A·B)/(|A|·|B|)
Berechnet den direkten Abstand zwischen zwei Punkten im mehrdimensionalen Raum. Geringere Distanz bedeutet größere Ähnlichkeit.
distance = √Σ(Ai - Bi)²
TikTok verwendet fortschrittliche Techniken zur Generierung und Aktualisierung der Embeddings:
Eine traditionelle Technik für Empfehlungssysteme, die Nutzer-Item-Interaktionen in kleinere Matrizen zerlegt:
# Pseudocode für Matrix-Faktorisierung
import numpy as np
# Nutzer-Video-Interaktionsmatrix (vereinfacht)
# Zeilen: Nutzer, Spalten: Videos, Werte: Interaktionsstärke
interactions = np.array([
[5, 3, 0, 1],
[4, 0, 0, 1],
[1, 1, 0, 5],
[0, 0, 4, 4]
])
# Faktorisieren in Nutzer- und Video-Vektoren
user_factors, video_factors = matrix_factorization(interactions, k=2)
# Vorhersage neuer Interaktionen
predicted_interactions = np.dot(user_factors, video_factors.T)
Matrix-Faktorisierung zerlegt die Interaktionsmatrix in kleinere Matrizen, wobei k die Anzahl der latenten Faktoren ist.
Moderne Empfehlungssysteme wie TikTok nutzen tiefe neuronale Netze für komplexere Darstellungen:
# Pseudocode für ein einfaches Embedding-Modell
import tensorflow as tf
# Eingangsschicht für Nutzer- und Video-IDs
user_input = tf.keras.layers.Input(shape=(1,))
video_input = tf.keras.layers.Input(shape=(1,))
# Embedding-Layer
user_embedding = tf.keras.layers.Embedding(
num_users, embedding_size)(user_input)
video_embedding = tf.keras.layers.Embedding(
num_videos, embedding_size)(video_input)
# Ähnlichkeitsberechnung
dot_product = tf.keras.layers.Dot(axes=2)([
user_embedding, video_embedding
])
# Modell erstellen und trainieren
model = tf.keras.Model(
inputs=[user_input, video_input],
outputs=dot_product
)
model.compile(optimizer='adam', loss='mse')
Deep Learning ermöglicht komplexere Beziehungen in den Embeddings und kann mit mehr Datentypen umgehen.
TikTok verwendet vermutlich Multi-Task Learning (MTL), bei dem das Modell mehrere Ziele gleichzeitig optimiert:
Diese unterschiedlichen Aufgaben werden gewichtet und zu einem Gesamtscore kombiniert, der die Rangfolge der Videos im Feed bestimmt.
Hier findest du einen vereinfachten Pseudocode, der die grundlegende Funktionsweise des TikTok-Algorithmus zeigt. In der Realität ist der Code natürlich viel komplexer, aber die Grundprinzipien sind ähnlich.
// Vereinfachter TikTok Empfehlungsalgorithmus
function generateForYouFeed(user_id, region, language, time, device_info):
// 1. Lade Nutzerdaten und extrahiere Features
user_data = loadUserData(user_id)
user_embedding = extractUserFeatures(user_data)
user_interests = getUserInterests(user_data)
user_history = getUserHistory(user_id)
// 2. Vorfilterung der Videokandiaten
candidate_videos = []
// 2.1 Regionsbasierte und sprachbasierte Filterung
base_pool = getVideosForRegionAndLanguage(region, language)
// 2.2 Füge Videos aus verschiedenen Quellen hinzu
candidate_videos.addAll(getPopularVideos(region, time))
candidate_videos.addAll(getVideosFromFollowedCreators(user_id))
candidate_videos.addAll(getSimilarToLikedVideos(user_history))
candidate_videos.addAll(getVideosFromSimilarUsers(user_embedding))
candidate_videos.addAll(getRandomVideosForExploration(user_interests))
// 2.3 Filterung basierend auf Nutzer-Präferenzen
candidate_videos = filterBasedOnUserPreferences(candidate_videos, user_data)
// 2.4 Entferne bereits gesehene Videos
candidate_videos = removeSeenVideos(candidate_videos, user_history)
// 3. Feature-Extraktion für Kandidaten-Videos
for each video in candidate_videos:
video.features = extractVideoFeatures(video)
video.embedding = getVideoEmbedding(video)
// 4. Scoring und Ranking
scored_videos = []
for each video in candidate_videos:
// 4.1 Berechne Relevanz-Score zwischen Nutzer und Video
relevance_score = calculateCosineSimilarity(user_embedding, video.embedding)
// 4.2 Berechne verschiedene Wahrscheinlichkeiten mit ML-Modellen
engagement_scores = {}
engagement_scores["watch_time"] = predictWatchTime(user_data, video)
engagement_scores["like_prob"] = predictLikeProbability(user_data, video)
engagement_scores["share_prob"] = predictShareProbability(user_data, video)
engagement_scores["comment_prob"] = predictCommentProbability(user_data, video)
engagement_scores["follow_creator_prob"] = predictFollowProbability(user_data, video)
// 4.3 Gewichteter Gesamtscore
total_score = calculateWeightedScore(relevance_score, engagement_scores)
scored_videos.add({video: video, score: total_score})
// 5. Sortiere Videos nach Score
ranked_videos = sortByScoreDescending(scored_videos)
// 6. Diversity-Optimierung: Stelle sicher, dass nicht zu viele ähnliche Videos hintereinander kommen
final_feed = diversifyFeed(ranked_videos)
// 7. Gibt final sortierten Feed zurück
return final_feed
// Helferfunktion zur Berechnung des gewichteten Scores
function calculateWeightedScore(relevance_score, engagement_scores):
total_score = 0
// Gewichte für verschiedene Faktoren (vereinfacht)
weights = {
"relevance": 0.3,
"watch_time": 0.3,
"like_prob": 0.15,
"share_prob": 0.15,
"comment_prob": 0.05,
"follow_creator_prob": 0.05
}
total_score += weights["relevance"] * relevance_score
total_score += weights["watch_time"] * engagement_scores["watch_time"]
total_score += weights["like_prob"] * engagement_scores["like_prob"]
total_score += weights["share_prob"] * engagement_scores["share_prob"]
total_score += weights["comment_prob"] * engagement_scores["comment_prob"]
total_score += weights["follow_creator_prob"] * engagement_scores["follow_creator_prob"]
return total_score
// Diversifizierungsfunktion
function diversifyFeed(ranked_videos):
diversified_feed = []
used_categories = Set()
while ranked_videos is not empty:
// Wähle das höchstbewertete Video
top_video = ranked_videos.removeHighest()
// Wenn wir kürzlich viele Videos aus dieser Kategorie hatten, verschiebe es nach hinten
if categoryOverrepresented(top_video.categories, used_categories):
ranked_videos.addWithPenalty(top_video)
continue
// Füge das Video zum Feed hinzu
diversified_feed.add(top_video)
used_categories.update(top_video.categories)
// Veraltete Kategorien aus dem Tracking entfernen
used_categories = removeOldCategories(used_categories)
return diversified_feed
Hier ist ein Python-Beispiel, das die Berechnung der Relevanz zwischen einem Nutzer und mehreren Videos demonstriert:
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
# Ein vereinfachtes Beispiel mit nur 5 Dimensionen
# In Wirklichkeit haben diese Vektoren hunderte oder tausende Dimensionen
# Nutzer-Embedding (Präferenzen für: Tanz, Comedy, DIY, Education, Gaming)
user_embedding = np.array([0.8, 0.6, 0.2, 0.4, 0.1]).reshape(1, -1)
# Video-Embeddings für 3 verschiedene Videos
video_embeddings = np.array([
[0.9, 0.7, 0.1, 0.2, 0.0], # Video 1: Stark Tanz- und Comedy-orientiert
[0.1, 0.2, 0.9, 0.8, 0.1], # Video 2: Stark DIY- und Education-orientiert
[0.7, 0.8, 0.2, 0.3, 0.1] # Video 3: Ähnlich wie Video 1, aber etwas anders gewichtet
])
# Berechnung der Kosinus-Ähnlichkeit
similarities = cosine_similarity(user_embedding, video_embeddings)
print("Ähnlichkeitswerte zwischen Nutzer und Videos:")
for i, similarity in enumerate(similarities[0]):
print(f"Video {i+1}: {similarity:.4f}")
# Sortieren der Videos nach Ähnlichkeit
ranked_indices = np.argsort(-similarities[0])
print("\nRanking der Videos:")
for rank, idx in enumerate(ranked_indices):
print(f"Rank {rank+1}: Video {idx+1} (Ähnlichkeit: {similarities[0][idx]:.4f})")
Ähnlichkeitswerte zwischen Nutzer und Videos:
Video 1: 0.9941
Video 2: 0.5491
Video 3: 0.9863
Ranking der Videos:
Rank 1: Video 1 (Ähnlichkeit: 0.9941)
Rank 2: Video 3 (Ähnlichkeit: 0.9863)
Rank 3: Video 2 (Ähnlichkeit: 0.5491)
In diesem Beispiel hätte der Nutzer, der Tanz und Comedy bevorzugt, Video 1 und 3 in seinem Feed ganz oben, während Video 2 (DIY und Education) weniger relevant wäre.
Einer der wichtigsten Aspekte des TikTok-Algorithmus ist die Echtzeitanpassung basierend auf Nutzerinteraktionen:
// Echtzeit-Feedback-Verarbeitung
function processUserFeedback(user_id, video_id, interaction_type, interaction_data):
// 1. Aktualisiere die Nutzerhistorie
updateUserHistory(user_id, video_id, interaction_type)
// 2. Verstärke relevante Interessen basierend auf der Interaktion
if interaction_type == "like" or interaction_type == "share" or interaction_type == "watch_complete":
video_categories = getVideoCategories(video_id)
increaseUserInterests(user_id, video_categories)
// 3. Bei negativer Interaktion, reduziere Interesse
if interaction_type == "not_interested" or interaction_type == "skip_quickly":
video_categories = getVideoCategories(video_id)
decreaseUserInterests(user_id, video_categories)
// 4. Aktualisiere das Nutzer-Embedding in Echtzeit
user_embedding = getUserEmbedding(user_id)
video_embedding = getVideoEmbedding(video_id)
// 4.1 Passe das Embedding je nach Interaktionstyp an
if isPositiveInteraction(interaction_type):
// Bewege das User-Embedding näher zum Video-Embedding
updated_embedding = updateEmbeddingPositive(user_embedding, video_embedding, learning_rate)
else:
// Bewege das User-Embedding weg vom Video-Embedding
updated_embedding = updateEmbeddingNegative(user_embedding, video_embedding, learning_rate)
// 4.2 Speichere das aktualisierte Embedding
saveUserEmbedding(user_id, updated_embedding)
// 5. Aktualisiere die Video-Statistiken
updateVideoStats(video_id, interaction_type)
// 6. Trainiere die Vorhersagemodelle inkrementell
if shouldUpdateModels(time_since_last_update):
updatePredictionModels(new_interaction_data)
// 7. Trigger für Neuberechnung des Feeds, falls nötig
if isSignificantInteraction(interaction_type):
triggerFeedRefresh(user_id)
// Funktion, um das User-Embedding in Richtung des Video-Embeddings zu bewegen
function updateEmbeddingPositive(user_embedding, video_embedding, learning_rate):
// Gradient Descent ähnlicher Ansatz
direction = video_embedding - user_embedding
updated_embedding = user_embedding + learning_rate * direction
return normalized(updated_embedding) // Normalisierung wichtig für Ähnlichkeitsberechnungen
Der TikTok-Algorithmus ist für seine schnelle Lernfähigkeit bekannt – oft bemerken Nutzer schon nach wenigen Minuten eine Anpassung ihres Feeds. Dies liegt an mehreren Faktoren:
Versuche, mit den folgenden vereinfachten Daten die Ähnlichkeit zwischen einem Nutzer und verschiedenen Videos zu berechnen und ein Ranking zu erstellen.
Wir arbeiten mit vereinfachten 3D-Vektoren, die drei Interessenkategorien repräsentieren: [Sport, Musik, Comedy]
[0.8, 0.3, 0.5]
Der Nutzer interessiert sich stark für Sport, mäßig für Comedy und weniger für Musik.
Berechne hier die Kosinus-Ähnlichkeit mit der Formel:
cos(θ) = (A·B) / (|A|·|B|)
Ähnlichkeit mit Video A:
Ähnlichkeit mit Video B:
Ähnlichkeit mit Video C:
Ähnlichkeit mit Video D:
Ordne die Videos nach absteigender Ähnlichkeit:
Dieses Material richtet sich an fortgeschrittene Schülerinnen und Schüler mit Interesse an Informatik, Mathematik und Datenwissenschaft. Es bietet tiefere Einblicke in die technischen Aspekte des TikTok-Algorithmus und ist besonders für Informatikkurse oder Wahlpflichtkurse im MINT-Bereich geeignet.
Einsatzmöglichkeiten im Unterricht:
Methodische Hinweise:
Fachliche Hinweise:
Lernziele:
Lösungen der praktischen Übung:
Für die Kosinus-Ähnlichkeit zwischen Nutzer [0.8, 0.3, 0.5] und den Videos:
Schritt 1: Berechnung des Skalarprodukts (A·B)
Schritt 2: Berechnung der Vektornormen (|A|, |B|)
Schritt 3: Berechnung der Kosinus-Ähnlichkeit cos(θ) = (A·B)/(|A|·|B|)
Ranking der Videos:
TikTok würde diesem Nutzer wahrscheinlich zuerst Videos D und A zeigen, da diese am besten zu seinen Interessen passen. Video B würde deutlich seltener oder nur zur Diversifizierung im Feed erscheinen.