Content-Strategie mit KI: Planung, Erstellung & Optimierung¶

import numpy as np
from sklearn.linear_model import LinearRegression

# Historische Daten (Beispiel)
# [Monat, Investition, Leads, Kunden]
historical_data = np.array([
    [1, 5000, 50, 5],
    [2, 5500, 60, 6],
    [3, 6000, 75, 8],
    [4, 6500, 80, 9],
    [5, 7000, 90, 10],
    [6, 7500, 100, 12]
])

# Zielvariablen
X = historical_data[:, [1, 2]]  # Investition, Leads
Y = historical_data[:, 3]      # Kunden

# Modell trainieren
model = LinearRegression()
model.fit(X, Y)

# Vorhersage für nächstes Quartal
next_quarter = np.array([[8000, 110]])  # Investition: 8000, erwartete Leads: 110
predicted_customers = model.predict(next_quarter)

print(f"Vorhergesagte Kunden: {predicted_customers[0]:.0f}")

import pandas as pd
from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Beispiel-Daten
customer_data = pd.DataFrame({
    'Age': [25, 35, 45, 22, 30, 40, 28, 38],
    'Income': [50000, 80000, 120000, 45000, 60000, 90000, 55000, 85000],
    'Engagement': [0.8, 0.6, 0.4, 0.9, 0.7, 0.5, 0.85, 0.65],
    'Purchase_Frequency': [5, 3, 1, 8, 4, 2, 6, 3]
})

# Normalisierung
scaler = StandardScaler()
scaled_data = scaler.fit_transform(customer_data)

# Clustering
kmeans = KMeans(n_clusters=3)
customer_data['Cluster'] = kmeans.fit_predict(scaled_data)

print("Personas basierend auf Clustering:")
for cluster in customer_data['Cluster'].unique():
    cluster_data = customer_data[customer_data['Cluster'] == cluster]
    print(f"\nPersona {cluster + 1}:")
    print(f"  Durchschnittsalter: {cluster_data['Age'].mean():.1f}")
    print(f"  Durchschnittseinkommen: ${cluster_data['Income'].mean():.0f}")
    print(f"  Durchschnitts-Engagement: {cluster_data['Engagement'].mean():.2f}")

import requests
from bs4 import BeautifulSoup
from collections import Counter

# Wettbewerber-Websites analysieren
def analyze_competitor_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.text, 'html.parser')

    # Themen extrahieren
    headings = [h.get_text().lower() for h in soup.find_all(['h1', 'h2', 'h3'])]

    # Keywords extrahieren
    words = [word.lower() for text in soup.stripped_strings 
             for word in text.split() if len(word) > 4]

    return {
        'headings': Counter(headings),
        'keywords': Counter(words)
    }

# Beispiel: Content-Gap-Analyse
competitors = [
    'https://competitor1.com/blog',
    'https://competitor2.com/resources',
    'https://competitor3.com/insights'
]

all_topics = Counter()
for url in competitors:
    analysis = analyze_competitor_content(url)
    all_topics.update(analysis['headings'])
    all_topics.update(analysis['keywords'])

print("Top Themen bei Wettbewerbern:")
for topic, count in all_topics.most_common(10):
    print(f"  {topic}: {count}")

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans

# Beispiel-Themen
topics = [
    "KI in der Content-Erstellung",
    "Wie man mit KI Blog-Posts schreibt",
    "KI-Tools für Social Media Marketing",
    "Automatisierte Übersetzungen mit KI",
    "KI für SEO-Optimierung",
    "Chatbots und Kundenservice",
    "KI in der Bildbearbeitung",
    "Video-Generierung mit KI",
    "KI für E-Mail-Marketing",
    "Personalisierung mit KI"
]

# TF-IDF Vektorisierung
vectorizer = TfidfVectorizer()
X = vectorizer.fit_transform(topics)

# Clustering
kmeans = KMeans(n_clusters=3)
clusters = kmeans.fit_predict(X)

# Themen nach Clustern gruppieren
clustered_topics = {}
for i, cluster in enumerate(clusters):
    if cluster not in clustered_topics:
        clustered_topics[cluster] = []
    clustered_topics[cluster].append(topics[i])

print("Themen-Cluster:")
for cluster, topics in clustered_topics.items():
    print(f"\nCluster {cluster + 1}:")
    for topic in topics:
        print(f"  - {topic}")

import pandas as pd
from datetime import datetime, timedelta
import random

# Content-Typen und ihre Häufigkeit
content_types = {
    'Blog-Post': {'frequency': 2, 'effort': 'high', 'impact': 'high'},
    'Social Media Post': {'frequency': 10, 'effort': 'low', 'impact': 'medium'},
    'Video': {'frequency': 1, 'effort': 'very high', 'impact': 'very high'},
    'Infografik': {'frequency': 1, 'effort': 'high', 'impact': 'high'},
    'E-Mail-Newsletter': {'frequency': 4, 'effort': 'medium', 'impact': 'high'},
    'Case Study': {'frequency': 1, 'effort': 'very high', 'impact': 'very high'},
    'Webinar': {'frequency': 1, 'effort': 'very high', 'impact': 'very high'}
}

# Kalender erstellen
def generate_content_calendar(start_date, weeks=12):
    calendar = []
    current_date = start_date

    for week in range(weeks):
        for day in range(7):  # Montag bis Sonntag
            date = current_date + timedelta(days=day)

            # Wochenende überspringen (optional)
            if date.weekday() >= 5:  # Samstag = 5, Sonntag = 6
                continue

            # Content-Typ basierend auf Häufigkeit auswählen
            # Einfachere Version: Zufällige Auswahl
            content_type = random.choice(list(content_types.keys()))

            calendar.append({
                'Date': date.strftime('%Y-%m-%d'),
                'Day': date.strftime('%A'),
                'Content Type': content_type,
                'Effort': content_types[content_type]['effort'],
                'Impact': content_types[content_type]['impact']
            })

        current_date += timedelta(weeks=1)

    return pd.DataFrame(calendar)

# Kalender generieren
start_date = datetime.today()
calendar = generate_content_calendar(start_date)
print(calendar.head(10))

import textstat

def analyze_readability(text):
    metrics = {
        'Flesch Reading Ease': textstat.flesch_reading_ease(text),
        'Flesch-Kincaid Grade': textstat.flesch_kincaid_grade(text),
        'SMOG Index': textstat.smog_index(text),
        'Coleman-Liau Index': textstat.coleman_liau_index(text),
        'Automated Readability Index': textstat.automated_readability_index(text),
        'Dale-Chall Readability Score': textstat.dale_chall_readability_score(text),
        'Difficult Words': textstat.difficult_words(text),
        'Linsear Write Formula': textstat.linsear_write_formula(text),
        'Gunning Fog': textstat.gunning_fog(text)
    }
    return metrics

# Beispiel
text = """
KI revolutioniert die Content-Erstellung. Mit modernen Tools können Marketer 
hochwertige Inhalte in einem Bruchteil der Zeit erstellen. Diese Technologien 
nutzen maschinelles Lernen, um Texte zu generieren, die kaum von menschlichen 
Autoren zu unterscheiden sind.
"""

readability = analyze_readability(text)
for metric, value in readability.items():
    print(f"{metric}: {value:.2f}")

import pandas as pd
from sklearn.ensemble import RandomForestClassifier

# Trainingsdaten (Beispiel)
data = pd.DataFrame({
    'Content_Type': ['Blog', 'Video', 'Infografik', 'Blog', 'Video'],
    'Topic': ['KI', 'Tutorial', 'KI', 'Marketing', 'KI'],
    'Length': [1500, 500, 200, 2000, 800],
    'Channel': ['LinkedIn', 'YouTube', 'Instagram', 'Blog', 'YouTube'],
    'Engagement': [150, 300, 200, 180, 250]
})

# Feature-Engineering
data['Content_Length'] = data['Length'] / 1000  # Normalisiert

# Modell trainieren
X = pd.get_dummies(data[['Content_Type', 'Topic', 'Content_Length']])
y = data['Channel']

model = RandomForestClassifier()
model.fit(X, y)

# Vorhersage für neuen Content
def predict_best_channel(content_type, topic, length):
    new_data = pd.DataFrame({
        'Content_Type': [content_type],
        'Topic': [topic],
        'Content_Length': [length / 1000]
    })
    new_data = pd.get_dummies(new_data)
    # Spalten anpassen
    for col in X.columns:
        if col not in new_data.columns:
            new_data[col] = 0
    new_data = new_data[X.columns]

    prediction = model.predict(new_data)
    return prediction[0]

# Beispiel
best_channel = predict_best_channel('Blog', 'KI', 1500)
print(f"Bester Kanal für Blog über KI mit 1500 Wörtern: {best_channel}")

# Pseudocode für automatisierte Verteilung
import hootsuite_api

def distribute_content(content, platforms):
    for platform in platforms:
        # Content für Plattform anpassen
        adapted_content = adapt_for_platform(content, platform)

        # Beste Zeit berechnen
        best_time = get_optimal_time(platform)

        # Post erstellen und planen
        hootsuite_api.create_scheduled_post(
            platform=platform,
            content=adapted_content,
            schedule_time=best_time
        )

from sklearn.ensemble import RandomForestRegressor
import pandas as pd

# Historische Content-Daten
data = pd.DataFrame({
    'Word_Count': [1000, 1500, 2000, 800, 1200],
    'Images': [3, 5, 2, 1, 4],
    'Videos': [0, 1, 0, 0, 1],
    'Keywords': [5, 8, 10, 3, 6],
    'Promotion_Spend': [100, 200, 150, 50, 180],
    'Views': [5000, 8000, 12000, 3000, 7000],
    'Shares': [50, 120, 80, 20, 90],
    'Conversions': [20, 45, 35, 10, 30]
})

# Modell trainieren
X = data[['Word_Count', 'Images', 'Videos', 'Keywords', 'Promotion_Spend']]
y_views = data['Views']
y_shares = data['Shares']
y_conversions = data['Conversions']

model_views = RandomForestRegressor()
model_views.fit(X, y_views)

model_shares = RandomForestRegressor()
model_shares.fit(X, y_shares)

# Vorhersage für neuen Content
def predict_performance(word_count, images, videos, keywords, spend):
    new_content = pd.DataFrame({
        'Word_Count': [word_count],
        'Images': [images],
        'Videos': [videos],
        'Keywords': [keywords],
        'Promotion_Spend': [spend]
    })

    predicted_views = model_views.predict(new_content)[0]
    predicted_shares = model_shares.predict(new_content)[0]

    return {
        'Views': int(predicted_views),
        'Shares': int(predicted_shares)
    }

# Beispiel
prediction = predict_performance(1500, 5, 1, 8, 200)
print(f"Vorhergesagte Performance: {prediction['Views']} Views, {prediction['Shares']} Shares")

# A/B-Test für Betreffzeilen
subject_variants = [
    "Entdecken Sie die Zukunft der Content-Erstellung",
    "Wie KI Ihre Content-Strategie revolutioniert",
    "5 KI-Tools, die jeder Marketer kennen sollte",
    "Sparen Sie Zeit mit KI-gestützter Content-Erstellung"
]

# KI-gestützte Vorhersage der Open Rates
def predict_open_rate(subject):
    # Vereinfachtes Modell
    keywords = ['Zukunft', 'revolutioniert', 'Tools', 'Zeit sparen', 'KI']
    score = sum(1 for kw in keywords if kw.lower() in subject.lower())
    return min(score * 5 + 20, 80)  # 20-80%

for subject in subject_variants:
    open_rate = predict_open_rate(subject)
    print(f"'{subject}': Vorhergesagte Open Rate: {open_rate}%")

import pandas as pd
from sklearn.cluster import KMeans

# Content-Daten (Beispiel)
data = pd.DataFrame({
    'Title': ['KI Grundlagen', 'Neues Feature X', 'Content-Strategie 2024', 'SEO-Tipps'],
    'Views': [5000, 1000, 2000, 3000],
    'Age_Days': [365, 30, 60, 180],
    'Shares': [50, 5, 10, 30],
    'Backlinks': [20, 2, 5, 15],
    'Bounce_Rate': [0.4, 0.7, 0.5, 0.45]
})

# Normalisierung
data_normalized = (data[['Views', 'Age_Days', 'Shares', 'Backlinks', 'Bounce_Rate']] -
                   data[['Views', 'Age_Days', 'Shares', 'Backlinks', 'Bounce_Rate']].min()) / \
                  (data[['Views', 'Age_Days', 'Shares', 'Backlinks', 'Bounce_Rate']].max() -
                   data[['Views', 'Age_Days', 'Shares', 'Backlinks', 'Bounce_Rate']].min())

# Clustering
kmeans = KMeans(n_clusters=2)
data['Cluster'] = kmeans.fit_predict(data_normalized)

# Evergreen Content identifizieren (Cluster mit hoher Performance & Alter)
evergreen_content = data[data['Cluster'] == 0]  # Annahme: Cluster 0 = Evergreen
print("Evergreen Content:")
print(evergreen_content[['Title', 'Views', 'Age_Days', 'Shares']])