Introduction
In today's fast-paced business environment, companies are increasingly turning to AI-powered tools to enhance their go-to-market strategies. This tutorial will guide you through creating a simple AI-powered lead scoring system using Python and popular machine learning libraries. This system will help sales teams prioritize leads based on their likelihood to convert, ultimately improving sales efficiency.
Prerequisites
Before starting this tutorial, you'll need:
- A basic understanding of Python programming
- Python 3.7 or higher installed on your computer
- Access to a command line or terminal
- Basic knowledge of data analysis concepts
Step-by-Step Instructions
1. Setting Up Your Development Environment
1.1 Install Required Python Packages
The first step is to install the necessary Python libraries for data analysis and machine learning. Open your terminal or command prompt and run:
pip install pandas scikit-learn numpyWhy we do this: These libraries provide essential functionality for handling data (pandas), implementing machine learning algorithms (scikit-learn), and performing numerical computations (numpy).
1.2 Create Your Project Directory
Create a new folder for your project and navigate to it:
mkdir lead_scoring_project
cd lead_scoring_projectWhy we do this: Organizing your code in a dedicated project directory helps maintain clean, manageable code structure.
2. Creating Sample Data
2.1 Generate Sample Lead Data
Create a file named lead_data.py and add the following code to generate sample lead data:
import pandas as pd
import numpy as np
# Generate sample lead data
data = {
'company_size': np.random.choice(['Small', 'Medium', 'Large'], 100),
'industry': np.random.choice(['Technology', 'Finance', 'Healthcare', 'Retail'], 100),
'website_traffic': np.random.randint(1000, 10000, 100),
'email_engagement': np.random.randint(0, 10, 100),
'social_media_activity': np.random.randint(0, 5, 100),
'previous_purchases': np.random.randint(0, 5, 100),
'lead_score': np.random.randint(0, 100, 100)
}
df = pd.DataFrame(data)
df.to_csv('leads.csv', index=False)
print('Sample data created successfully!')
print(df.head())Why we do this: We create realistic sample data that mimics real-world lead information, which is essential for training our AI model.
2.2 Run the Data Generation Script
Execute the script by running:
python lead_data.pyWhy we do this: This creates a CSV file containing sample lead data that we'll use for our machine learning model.
3. Building the Lead Scoring Model
3.1 Create the Main Model Script
Create a new file named lead_scoring_model.py and add the following code:
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import LabelEncoder
from sklearn.metrics import accuracy_score
# Load the data
df = pd.read_csv('leads.csv')
# Display basic information about the data
print('Data Shape:', df.shape)
print('\nFirst 5 rows:')
print(df.head())
# Encode categorical variables
le_company = LabelEncoder()
le_industry = LabelEncoder()
df['company_size_encoded'] = le_company.fit_transform(df['company_size'])
df['industry_encoded'] = le_industry.fit_transform(df['industry'])
# Prepare features and target
features = ['company_size_encoded', 'industry_encoded', 'website_traffic',
'email_engagement', 'social_media_activity', 'previous_purchases']
target = 'lead_score'
# Create a binary classification problem (convert lead_score to high/low)
# We'll consider leads with score > 50 as 'high value'
df['high_value'] = (df['lead_score'] > 50).astype(int)
# Prepare the data for training
X = df[features]
y = df['high_value']
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Create and train the model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)
# Make predictions
y_pred = model.predict(X_test)
# Calculate accuracy
accuracy = accuracy_score(y_test, y_pred)
print(f'\nModel Accuracy: {accuracy:.2f}')
# Display feature importance
feature_importance = pd.DataFrame({
'feature': features,
'importance': model.feature_importances_
})
print('\nFeature Importance:')
print(feature_importance.sort_values('importance', ascending=False))Why we do this: This script prepares our data, trains a machine learning model, and evaluates its performance to determine which factors are most important in lead scoring.
3.2 Run the Model Script
Execute the model script:
python lead_scoring_model.pyWhy we do this: Running this script trains our AI model on the sample data and shows us which factors are most important in determining lead quality.
4. Using the Model to Score New Leads
4.1 Create a Lead Scoring Function
Create a new file named score_leads.py and add:
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import LabelEncoder
import joblib
# Load the trained model and encoders
model = joblib.load('lead_model.pkl')
le_company = joblib.load('le_company.pkl')
le_industry = joblib.load('le_industry.pkl')
# Function to score a new lead
def score_lead(company_size, industry, website_traffic, email_engagement,
social_media_activity, previous_purchases):
# Encode categorical variables
try:
company_size_encoded = le_company.transform([company_size])[0]
except ValueError:
company_size_encoded = 0 # Default value for unknown category
try:
industry_encoded = le_industry.transform([industry])[0]
except ValueError:
industry_encoded = 0 # Default value for unknown category
# Prepare input data
input_data = np.array([[company_size_encoded, industry_encoded, website_traffic,
email_engagement, social_media_activity, previous_purchases]])
# Make prediction
prediction = model.predict(input_data)[0]
probability = model.predict_proba(input_data)[0]
return {
'is_high_value': bool(prediction),
'confidence': max(probability),
'score': float(probability[1]) if prediction == 1 else float(probability[0])
}
# Example usage
if __name__ == '__main__':
# Score a new lead
result = score_lead('Medium', 'Technology', 5000, 7, 3, 2)
print('Lead Scoring Result:')
print(f'High Value Lead: {result["is_high_value"]}')
print(f'Confidence: {result["confidence"]:.2f}')
print(f'Score: {result["score"]:.2f}')Why we do this: This function allows us to easily score new leads using our trained model, simulating how the AI would work in a real business environment.
4.2 Save Your Trained Model
Modify your model script to save the trained model and encoders:
# Add these lines at the end of your lead_scoring_model.py file
# Save the trained model and encoders
joblib.dump(model, 'lead_model.pkl')
joblib.dump(le_company, 'le_company.pkl')
joblib.dump(le_industry, 'le_industry.pkl')
print('Model and encoders saved successfully!')Why we do this: Saving our trained model allows us to reuse it later without retraining, which is essential for practical business applications.
5. Testing Your Complete System
5.1 Run the Complete Workflow
First, re-run your model script to save the trained components:
python lead_scoring_model.pyThen test the scoring function:
python score_leads.pyWhy we do this: This ensures our complete system works correctly from data generation to lead scoring.
6. Interpreting Results and Next Steps
6.1 Analyze the Output
After running the scripts, you'll see:
- Model accuracy score
- Feature importance rankings
- Individual lead scoring results
Why we do this: Understanding these results helps you make informed decisions about which lead characteristics matter most for your business.
Summary
In this tutorial, you've learned how to create a basic AI-powered lead scoring system using Python and machine learning. You've built a system that can:
- Process lead data
- Train a machine learning model
- Score new leads based on their characteristics
- Identify which factors are most important in lead conversion
This foundation can be expanded to include more sophisticated features, real-time data integration, and advanced AI techniques as your business grows. The key takeaway is that AI tools like this can help sales teams prioritize their efforts more effectively, addressing the paradox mentioned in the article where technology investments don't always translate to improved sales performance.
