Come l’Intelligenza Artificiale può creare il nuovo marketing: determinare il Conversion Rate

In questo articolo vedremo come l’intelligenza artificiale (IA) sta rivoluzionando il marketing moderno, in particolare per quanto riguarda la determinazione del conversion rate. Spiegheremo cosa sia il conversion rate, perché è fondamentale nel marketing e come possiamo utilizzare il machine learning per analizzarlo partendo dal dataset conversion.csv.

Cos’è il Conversion Rate e perché è fondamentale

Il conversion rate è la percentuale di utenti che compiono una determinata azione di valore, come ad esempio l’acquisto di un prodotto, l’iscrizione a una newsletter o la richiesta di informazioni. Si calcola come rapporto tra il numero di conversioni e il numero totale di visitatori o utenti.

Nel marketing è uno degli indicatori più importanti perché misura direttamente l’efficacia di una campagna o di un sito web nel trasformare i visitatori in clienti o lead.

Esempi di utilizzo:

• Un e-commerce vuole capire quali categorie di clienti convertono maggiormente per ottimizzare le campagne pubblicitarie.
• Una piattaforma SaaS misura il tasso di conversione delle demo gratuite in abbonamenti paganti.
• Un sito di formazione analizza quali livelli di istruzione o professioni hanno maggior successo nella registrazione a corsi online.

Analisi preliminare del Conversion Rate per Job e Education con Python

Per capire come il conversion rate varia in base a lavoro (job) ed educazione (education), carichiamo il dataset e creiamo alcuni grafici esplorativi.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import re

# Caricamento dataset con separatore ';'
url = "https://www.liviobollini.it/dati/conversion.csv"
df = pd.read_csv(url, sep=';')

# Pulizia nomi colonne: rimuove spazi, apostrofi e caratteri non alfanumerici
df.columns = [re.sub(r'\W+', '', col).strip() for col in df.columns]

# Conversione variabile target 'y' in 0/1
df['conversion'] = df['y'].apply(lambda x: 0 if x.lower() == 'no' else 1)

# Calcolo conversion rate per job
job_conversion = df.groupby('job')['conversion'].mean().sort_values(ascending=False)

# Calcolo conversion rate per education
education_conversion = df.groupby('education')['conversion'].mean().sort_values(ascending=False)

# Grafico conversion rate per job
plt.figure(figsize=(10,6))
sns.barplot(x=job_conversion.values, y=job_conversion.index, palette='viridis')
plt.title('Conversion Rate per Job')
plt.xlabel('Conversion Rate')
plt.ylabel('Job')
plt.tight_layout()
plt.show()

# Grafico conversion rate per education
plt.figure(figsize=(10,6))
sns.barplot(x=education_conversion.values, y=education_conversion.index, palette='magma')
plt.title('Conversion Rate per Education')
plt.xlabel('Conversion Rate')
plt.ylabel('Education')
plt.tight_layout()
plt.show()
    

Preprocessing delle variabili categoriche

Nel dataset, molte colonne sono categoriche. Per applicare algoritmi di machine learning come l’albero decisionale, dobbiamo convertire queste variabili in valori numerici.

Per la variabile target abbiamo usato una lambda semplice, ma per le altre variabili scegliamo tra:

• unique(): per controllare i valori unici e decidere come codificare;
• get_dummies(): per trasformare variabili categoriche in variabili dummy (one-hot encoding);
• lambda: per mappature personalizzate se la codifica è semplice.

Ad esempio:

• Job codificato con get_dummies() perché ha molte categorie non ordinate.
• Education codificata con mappatura lambda per ordinalità (es. “primary” → 1, “secondary” → 2, “tertiary” → 3).
• Marital potrebbe essere codificato con unique e mappatura lambda.

Applicazione dell’albero decisionale con criterio Gini e split dei dati

Ora applichiamo un albero decisionale per prevedere la conversione. Mostreremo anche come dividere il dataset in training e test e confrontare due criteri di split: Gini impurity e Entropy information gain.

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import re
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# 1. Caricamento del dataset con separatore ';'
url = "https://www.liviobollini.it/dati/conversion.csv"
df = pd.read_csv(url, sep=';')

# 2. Pulizia nomi colonne: rimuove caratteri non alfanumerici e spazi
df.columns = [re.sub(r'\W+', '', col).strip() for col in df.columns]

# 3. Conversione variabile target 'y' in 0/1
df['conversion'] = df['y'].apply(lambda x: 0 if x.lower() == 'no' else 1)


# 4. Preprocessing per il modello ML
df_processed = df.copy()

# 5. Codifica education (variabile ordinata)
education_map = {'primary': 1, 'secondary': 2, 'tertiary': 3}
df_processed['education'] = df_processed['education'].map(education_map)

# 6. Rimozione righe con education non riconosciuta (es. 'unknown')
df_processed = df_processed.dropna(subset=['education'])

# 7. Codifica job con one-hot encoding
job_dummies = pd.get_dummies(df_processed['job'], prefix='job')
df_processed = pd.concat([df_processed.drop('job', axis=1), job_dummies], axis=1)

# 8. Rimozione colonne non numeriche (es. stringhe residue tipo 'y')
non_numeric_cols = df_processed.select_dtypes(exclude=[np.number]).columns
df_processed = df_processed.drop(non_numeric_cols, axis=1)

# 9. Separazione feature e target
X = df_processed.drop(['conversion'], axis=1)
y = df_processed['conversion']

# 10. Reset index
X = X.reset_index(drop=True)
y = y.reset_index(drop=True)

# 11. Divisione in train e test set
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# 12. Decision Tree con criterio Gini
clf_gini = DecisionTreeClassifier(criterion='gini', random_state=42)
clf_gini.fit(X_train, y_train)

# 13. Decision Tree con criterio Entropy
clf_entropy = DecisionTreeClassifier(criterion='entropy', random_state=42)
clf_entropy.fit(X_train, y_train)

# 14. Valutazione modelli
y_pred_gini = clf_gini.predict(X_test)
y_pred_entropy = clf_entropy.predict(X_test)

print(f"Accuracy Gini: {accuracy_score(y_test, y_pred_gini):.3f}")
print(f"Accuracy Entropy: {accuracy_score(y_test, y_pred_entropy):.3f}")

    

Esempio pratico con predict

Una volta addestrato il modello, possiamo fare previsioni su nuovi dati. Ecco un esempio di come usare il metodo predict con un campione:

# Esempio di nuovo dato (deve avere le stesse colonne di X)
import numpy as np

# Costruisci un array di esempio (adatta in base alle colonne di X)
sample = np.array([[2,  # education: secondary (2)
                    0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]])  

prediction = clf_gini.predict(sample)
print(f"Predizione conversione: {prediction[0]} (0=no, 1=yes)")
    

Approfondimenti sul processo Decision Tree

Per approfondire il funzionamento degli alberi decisionali, consigliamo:

• Articolo su Livio Bollini - Alberi decisionali
• Scikit-learn Decision Tree Documentation
• Machine Learning Mastery - Decision Trees

Come testare il codice su Google Colab

Il codice Python mostrato può essere facilmente testato su Google Colab, un ambiente gratuito e online per eseguire notebook Python.

Per usare Google Colab:

• Vai su https://colab.research.google.com
• Crea un nuovo notebook Python
• Copia e incolla i blocchi di codice uno alla volta nel notebook
• Esegui le celle per vedere i risultati, grafici e output

Conclusione

L’intelligenza artificiale offre strumenti potenti per ottimizzare il marketing, in particolare per calcolare e prevedere il conversion rate, un indicatore chiave per misurare il successo delle campagne. Utilizzando dataset reali e tecniche di machine learning come gli alberi decisionali, è possibile individuare pattern nascosti e migliorare le strategie di targeting e comunicazione.

Questo approccio non solo aumenta l’efficacia delle campagne, ma consente anche di risparmiare risorse concentrandosi sui segmenti di mercato con maggior potenziale di conversione. Infine, l’utilizzo di piattaforme gratuite come Google Colab facilita la sperimentazione e la prototipazione rapida di modelli predittivi.