Data-Driven MarketingSuccess Stories

# SEO Performance Analysis Pipeline
import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

def analyze_keyword_performance(keywords_df):
    """Analyze keyword performance and identify optimization opportunities"""
    
    # Calculate keyword difficulty vs opportunity score
    keywords_df['opportunity_score'] = (
        keywords_df['search_volume'] * keywords_df['ctr'] / 
        (keywords_df['difficulty'] + 1)
    )
    
    # Cluster keywords by performance characteristics
    features = ['search_volume', 'difficulty', 'current_position']
    kmeans = KMeans(n_clusters=4, random_state=42)
    keywords_df['cluster'] = kmeans.fit_predict(keywords_df[features])
    
    return keywords_df.sort_values('opportunity_score', ascending=False)

# Example usage
top_opportunities = analyze_keyword_performance(keyword_data)
print(f"Identified {len(top_opportunities)} high-opportunity keywords")

# SEM Bid Optimization Model
import tensorflow as tf
from tensorflow import keras
import numpy as np

class BidOptimizationModel:
    def __init__(self, input_features=10):
        self.model = self._build_model(input_features)
        
    def _build_model(self, input_features):
        """Build neural network for bid optimization"""
        model = keras.Sequential([
            keras.layers.Dense(64, activation='relu', input_shape=(input_features,)),
            keras.layers.Dropout(0.3),
            keras.layers.Dense(32, activation='relu'),
            keras.layers.Dense(16, activation='relu'),
            keras.layers.Dense(1, activation='linear')  # Bid amount output
        ])
        
        model.compile(
            optimizer='adam',
            loss='mse',
            metrics=['mae']
        )
        return model
    
    def predict_optimal_bid(self, campaign_features):
        """Predict optimal bid based on campaign features"""
        return self.model.predict(campaign_features)

# Initialize and train model
bid_optimizer = BidOptimizationModel()
optimal_bids = bid_optimizer.predict_optimal_bid(campaign_data)

# Multi-Touch Attribution Model
import pandas as pd
import numpy as np
from itertools import combinations

class AttributionModel:
    def __init__(self, touchpoint_data):
        self.data = touchpoint_data
        self.conversion_paths = self._prepare_paths()
    
    def shapley_attribution(self):
        """Calculate Shapley values for channel attribution"""
        channels = self.data['channel'].unique()
        attributions = {}
        
        for channel in channels:
            marginal_contributions = []
            
            # Calculate marginal contribution across all possible coalitions
            for r in range(len(channels)):
                for coalition in combinations(channels, r):
                    if channel not in coalition:
                        with_channel = self._conversion_rate(list(coalition) + [channel])
                        without_channel = self._conversion_rate(list(coalition))
                        marginal_contributions.append(with_channel - without_channel)
            
            attributions[channel] = np.mean(marginal_contributions)
        
        return attributions
    
    def _conversion_rate(self, channels):
        """Calculate conversion rate for given channel combination"""
        filtered_paths = self.conversion_paths[
            self.conversion_paths['channels'].apply(
                lambda x: all(ch in x for ch in channels)
            )
        ]
        return filtered_paths['converted'].mean()

# Run attribution analysis
attribution_model = AttributionModel(journey_data)
channel_attributions = attribution_model.shapley_attribution()