|
|
--- |
|
|
license: mit |
|
|
library_name: stable-baselines3 |
|
|
tags: |
|
|
- reinforcement-learning |
|
|
- sales |
|
|
- conversation-analysis |
|
|
- conversion-prediction |
|
|
- ppo |
|
|
- turn-by-turn-analysis |
|
|
language: |
|
|
- en |
|
|
pipeline_tag: reinforcement-learning |
|
|
inference: true |
|
|
datasets: |
|
|
- synthetic |
|
|
metrics: |
|
|
- name: Conversion Prediction Accuracy |
|
|
type: accuracy |
|
|
value: 0.967 |
|
|
- name: Inference Time |
|
|
type: speed |
|
|
value: 85 |
|
|
widget: |
|
|
- text: "user: I'm interested in your product\nassistant: Thank you for your interest. How can I help you today?" |
|
|
example_title: Early Stage Prospect |
|
|
- text: "user: What's your pricing?\nassistant: Our plans start at $10/user/month" |
|
|
example_title: Price Discussion |
|
|
--- |
|
|
|
|
|
# Sales Conversation Analysis Model - Turn-by-Turn Prediction |
|
|
|
|
|
[](https://www.python.org/downloads/) |
|
|
[](https://opensource.org/licenses/MIT) |
|
|
|
|
|
A reinforcement learning model trained to analyze sales conversations and predict conversion probability evolution turn-by-turn. **Specializes in tracking how each message impacts sales success** using advanced PPO and LLM-powered metrics. |
|
|
|
|
|
**Paper**: [SalesRLAgent: A Reinforcement Learning Approach for Real-Time Sales Conversion Prediction and Optimization](https://arxiv.org/abs/2503.23303) |
|
|
**Author**: Nandakishor M |
|
|
**Published**: arXiv:2503.23303 |
|
|
|
|
|
## 🚀 Quick Start with This Model |
|
|
|
|
|
### Installation |
|
|
```bash |
|
|
# Requires Python 3.11 for optimal compatibility |
|
|
pip install deepmost[gpu] # Recommended for LLM features |
|
|
``` |
|
|
|
|
|
### Method 1: Direct URL Download (Easiest) |
|
|
```python |
|
|
from deepmost import sales |
|
|
|
|
|
# Automatically download and use this specific model from Hugging Face |
|
|
agent = sales.Agent( |
|
|
model_path="https://huggingface.co/DeepMostInnovations/sales-conversion-model-reinf-learning/resolve/main/sales_conversion_model.zip", |
|
|
llm_model="unsloth/Qwen3-4B-GGUF", # For dynamic metrics |
|
|
auto_download=True # Downloads and caches the model automatically |
|
|
) |
|
|
|
|
|
conversation = [ |
|
|
"Hello, I'm looking for information on your new AI-powered CRM", |
|
|
"You've come to the right place! Our AI CRM helps increase sales efficiency. What challenges are you facing?", |
|
|
"We struggle with lead prioritization and follow-up timing", |
|
|
"Excellent! Our AI automatically analyzes leads and suggests optimal follow-up times. Would you like to see a demo?", |
|
|
"That sounds interesting. What's the pricing like?" |
|
|
] |
|
|
|
|
|
# Get turn-by-turn analysis |
|
|
results = agent.analyze_conversation_progression(conversation, print_results=True) |
|
|
``` |
|
|
|
|
|
**Output:** |
|
|
``` |
|
|
Turn 1 (customer): "Hello, I'm looking for information on your new AI-pow..." -> Probability: 0.1744 |
|
|
Turn 2 (sales_rep): "You've come to the right place! Our AI CRM helps increa..." -> Probability: 0.3292 |
|
|
Turn 3 (customer): "We struggle with lead prioritization and follow-up timing" -> Probability: 0.4156 |
|
|
Turn 4 (sales_rep): "Excellent! Our AI automatically analyzes leads and sugge..." -> Probability: 0.3908 |
|
|
Turn 5 (customer): "That sounds interesting. What's the pricing like?" -> Probability: 0.5234 |
|
|
|
|
|
Final Conversion Probability: 52.34% |
|
|
Final Status: 🟡 Medium |
|
|
``` |
|
|
|
|
|
> **Note**: When using Method 1 (URL), the model is automatically downloaded and cached locally in `~/.deepmost/models/` for faster subsequent usage. |
|
|
|
|
|
### Method 2: Clone Repository (For Offline Use) |
|
|
```bash |
|
|
git lfs install |
|
|
git clone https://huggingface.co/DeepMostInnovations/sales-conversion-model-reinf-learning |
|
|
cd sales-conversion-model-reinf-learning |
|
|
``` |
|
|
|
|
|
```python |
|
|
from deepmost import sales |
|
|
|
|
|
# Use the local model file |
|
|
agent = sales.Agent( |
|
|
model_path="./sales_conversion_model.zip", # Local file path |
|
|
llm_model="unsloth/Qwen3-4B-GGUF" |
|
|
) |
|
|
|
|
|
# Same analysis as above |
|
|
results = agent.analyze_conversation_progression(conversation, print_results=True) |
|
|
``` |
|
|
|
|
|
## 🎯 Model Architecture & Features |
|
|
|
|
|
### Technical Details |
|
|
- **Framework**: Stable Baselines3 (PPO) |
|
|
- **State Representation**: Multi-modal (embeddings + LLM-derived metrics) |
|
|
- **Action Space**: Continuous (conversion probability 0-1) |
|
|
- **Feature Extractor**: Custom Linear layers optimized for conversation analysis |
|
|
- **Embeddings**: BAAI/bge-m3 (1024-dim) with optional Azure OpenAI support |
|
|
- **Dynamic Metrics**: LLM-powered customer engagement and sales effectiveness analysis |
|
|
|
|
|
### Key Capabilities |
|
|
- **Turn-by-Turn Analysis**: Track probability evolution throughout conversations |
|
|
- **Real-time Insights**: 85ms inference speed vs 3450ms for GPT-4 |
|
|
- **Dynamic Metrics**: LLM analyzes engagement and effectiveness in real-time |
|
|
- **Sales Training**: Identify which conversation elements increase conversion |
|
|
- **A/B Testing**: Compare different sales approaches quantitatively |
|
|
|
|
|
## 📊 Model Performance |
|
|
|
|
|
According to the research paper, this model achieves: |
|
|
- **96.7% accuracy** in conversion prediction |
|
|
- **34.7% improvement** over LLM-only approaches |
|
|
- **85ms inference time** vs 3450ms for GPT-4 |
|
|
- **43.2% increase** in conversion rates when used by sales representatives |
|
|
|
|
|
### Training Data |
|
|
- 100,000+ synthetic sales conversations generated using large language models |
|
|
- Multiple customer types and conversation scenarios |
|
|
- Semantic embeddings capturing conversation meaning and context |
|
|
- Dynamic metrics for engagement and sales effectiveness |
|
|
|
|
|
## 💡 Use Cases |
|
|
|
|
|
### 1. Sales Training & Coaching |
|
|
```python |
|
|
# Analyze what makes conversations successful |
|
|
training_conversation = [ |
|
|
{"speaker": "customer", "message": "I'm comparing different CRM vendors"}, |
|
|
{"speaker": "sales_rep", "message": "Smart approach! What's most important to you?"}, |
|
|
{"speaker": "customer", "message": "Integration with existing tools"}, |
|
|
{"speaker": "sales_rep", "message": "We integrate with 200+ tools. Which do you use?"} |
|
|
] |
|
|
|
|
|
results = agent.analyze_conversation_progression(training_conversation) |
|
|
|
|
|
# Identify turns that increased/decreased probability |
|
|
for i, result in enumerate(results[1:], 1): |
|
|
change = result['probability'] - results[i-1]['probability'] |
|
|
trend = "📈" if change > 0 else "📉" if change < 0 else "➡️" |
|
|
print(f"Turn {i+1}: {trend} {change:+.3f} change") |
|
|
``` |
|
|
|
|
|
### 2. A/B Testing Sales Scripts |
|
|
```python |
|
|
# Compare different response strategies |
|
|
script_a = ["I need pricing", "Our Pro plan is $99/month per user"] |
|
|
script_b = ["I need pricing", "What's your team size? I'll get you accurate pricing"] |
|
|
|
|
|
results_a = agent.analyze_conversation_progression(script_a, print_results=False) |
|
|
results_b = agent.analyze_conversation_progression(script_b, print_results=False) |
|
|
|
|
|
print(f"Script A: {results_a[-1]['probability']:.2%}") |
|
|
print(f"Script B: {results_b[-1]['probability']:.2%}") |
|
|
``` |
|
|
|
|
|
### 3. Real-time Sales Assistance |
|
|
```python |
|
|
# Get guidance during live conversations |
|
|
current_conversation = [ |
|
|
{"speaker": "customer", "message": "Your solution looks expensive"}, |
|
|
{"speaker": "sales_rep", "message": "I understand the investment concern..."} |
|
|
] |
|
|
|
|
|
results = agent.analyze_conversation_progression(current_conversation, print_results=False) |
|
|
current_metrics = results[-1]['metrics'] |
|
|
|
|
|
if current_metrics['customer_engagement'] < 0.5: |
|
|
print("💡 Suggestion: Customer engagement low. Ask open-ended questions.") |
|
|
elif current_metrics['sales_effectiveness'] < 0.5: |
|
|
print("💡 Suggestion: Refine approach. Focus on value proposition.") |
|
|
``` |
|
|
|
|
|
## 🔧 Configuration Options |
|
|
|
|
|
### Backend Selection |
|
|
```python |
|
|
# Use open-source backend (recommended) |
|
|
agent = sales.Agent( |
|
|
model_path="./sales_conversion_model.zip", # This model |
|
|
embedding_model="BAAI/bge-m3", |
|
|
llm_model="unsloth/Qwen3-4B-GGUF", |
|
|
use_gpu=True |
|
|
) |
|
|
|
|
|
# Use Azure OpenAI backend (if you have Azure credentials) |
|
|
agent = sales.Agent( |
|
|
model_path="./sales_model.zip", # Azure-trained variant |
|
|
azure_api_key="your_key", |
|
|
azure_endpoint="your_endpoint", |
|
|
azure_deployment="text-embedding-3-large", |
|
|
llm_model="unsloth/Qwen3-4B-GGUF" |
|
|
) |
|
|
``` |
|
|
|
|
|
### LLM Model Options |
|
|
```python |
|
|
# Recommended models for dynamic metrics |
|
|
agent = sales.Agent( |
|
|
model_path="./sales_conversion_model.zip", |
|
|
llm_model="unsloth/Qwen3-4B-GGUF" # Recommended |
|
|
# llm_model="unsloth/Llama-3.2-3B-Instruct-GGUF" # Alternative |
|
|
# llm_model="unsloth/Llama-3.1-8B-Instruct-GGUF" # Higher quality |
|
|
) |
|
|
``` |
|
|
|
|
|
## 📈 Advanced Analysis |
|
|
|
|
|
### Conversation Trend Visualization |
|
|
```python |
|
|
import matplotlib.pyplot as plt |
|
|
|
|
|
scenarios = { |
|
|
"Successful Sale": [ |
|
|
"I need a CRM", "What's your team size?", "10 people", |
|
|
"Perfect! Our Pro plan fits 5-20 users", "Sounds good!" |
|
|
], |
|
|
"Price Objection": [ |
|
|
"I need a CRM", "Our premium solution is $99/month", |
|
|
"Too expensive", "Let me show ROI...", "Still too much" |
|
|
] |
|
|
} |
|
|
|
|
|
plt.figure(figsize=(12, 6)) |
|
|
for scenario_name, conversation in scenarios.items(): |
|
|
results = agent.analyze_conversation_progression(conversation, print_results=False) |
|
|
probabilities = [r['probability'] for r in results] |
|
|
turns = list(range(1, len(probabilities) + 1)) |
|
|
|
|
|
plt.plot(turns, probabilities, marker='o', linewidth=2, label=scenario_name) |
|
|
|
|
|
plt.xlabel('Conversation Turn') |
|
|
plt.ylabel('Conversion Probability') |
|
|
plt.title('Conversion Probability Evolution by Scenario') |
|
|
plt.legend() |
|
|
plt.grid(True, alpha=0.3) |
|
|
plt.show() |
|
|
``` |
|
|
|
|
|
## 🛠️ Installation & Setup |
|
|
|
|
|
### Requirements |
|
|
- **Python 3.11** (required for optimal compatibility) |
|
|
- PyTorch with optional CUDA support |
|
|
- Hugging Face Transformers |
|
|
- llama-cpp-python for LLM features |
|
|
|
|
|
### GPU Support Setup |
|
|
```bash |
|
|
# For NVIDIA CUDA |
|
|
CMAKE_ARGS="-DGGML_CUDA=on" pip install llama-cpp-python --upgrade --force-reinstall --no-cache-dir |
|
|
|
|
|
# For Apple Metal (M1/M2/M3) |
|
|
CMAKE_ARGS="-DGGML_METAL=on" pip install llama-cpp-python --upgrade --force-reinstall --no-cache-dir |
|
|
|
|
|
# Install DeepMost |
|
|
pip install deepmost[gpu] |
|
|
``` |
|
|
|
|
|
### Verify Installation |
|
|
```python |
|
|
import torch |
|
|
from deepmost import sales |
|
|
|
|
|
print(f"CUDA Available: {torch.cuda.is_available()}") |
|
|
info = sales.get_system_info() |
|
|
print(f"Supported Backends: {info['supported_backends']}") |
|
|
``` |
|
|
|
|
|
## 📊 Understanding Results |
|
|
|
|
|
Each turn analysis provides detailed metrics: |
|
|
|
|
|
```python |
|
|
{ |
|
|
'turn': 1, # Turn number (1-indexed) |
|
|
'speaker': 'customer', # Who spoke |
|
|
'message': 'I need a CRM', # Actual message |
|
|
'probability': 0.3456, # Conversion probability |
|
|
'status': '🟠 Low', # Visual indicator |
|
|
'metrics': { |
|
|
'customer_engagement': 0.6, # LLM-derived score (0-1) |
|
|
'sales_effectiveness': 0.4, # LLM-derived score (0-1) |
|
|
'conversation_length': 3.0, # Number of messages |
|
|
'progress': 0.15 # Conversation progress |
|
|
} |
|
|
} |
|
|
``` |
|
|
|
|
|
### Status Indicators |
|
|
- 🟢 **High** (≥70%): Strong conversion potential |
|
|
- 🟡 **Medium** (≥50%): Good potential, build value |
|
|
- 🟠 **Low** (≥30%): Needs improvement, re-engage |
|
|
- 🔴 **Very Low** (<30%): Poor fit, consider re-qualifying |
|
|
|
|
|
## 🎓 Research Context |
|
|
|
|
|
This model implements the SalesRLAgent approach described in the research paper. Key innovations include: |
|
|
|
|
|
1. **Reinforcement Learning Framework**: PPO-based training for conversation analysis |
|
|
2. **Multi-modal State Representation**: Combines embeddings with dynamic metrics |
|
|
3. **Real-time Performance**: Optimized for production sales environments |
|
|
4. **Turn-by-Turn Analysis**: Novel approach to tracking conversation evolution |
|
|
|
|
|
### Model Learned Patterns |
|
|
The model identifies key conversation dynamics: |
|
|
- Technical buyers respond to detailed feature discussions |
|
|
- Price-conscious customers need ROI justification |
|
|
- Early-stage prospects require thorough needs assessment |
|
|
- Engagement patterns that predict successful outcomes |
|
|
|
|
|
## 📝 Model Files |
|
|
|
|
|
This repository contains: |
|
|
- `sales_conversion_model.zip` - Open-source trained model (recommended) |
|
|
- `sales_model.zip` - Azure OpenAI trained variant |
|
|
- Training and inference scripts |
|
|
- Sample conversation data |
|
|
|
|
|
## 🤝 Contributing & Usage |
|
|
|
|
|
### Using in Your Applications |
|
|
```python |
|
|
# Initialize with this specific model |
|
|
agent = sales.Agent( |
|
|
model_path="https://huggingface.co/DeepMostInnovations/sales-conversion-model-reinf-learning/resolve/main/sales_conversion_model.zip", |
|
|
llm_model="unsloth/Qwen3-4B-GGUF" |
|
|
) |
|
|
|
|
|
# Integrate into your sales tools |
|
|
def analyze_sales_call(conversation_messages): |
|
|
results = agent.analyze_conversation_progression(conversation_messages) |
|
|
return { |
|
|
'final_probability': results[-1]['probability'], |
|
|
'trend': 'improving' if results[-1]['probability'] > results[0]['probability'] else 'declining', |
|
|
'recommendations': generate_recommendations(results) |
|
|
} |
|
|
``` |
|
|
|
|
|
### Custom Training |
|
|
To train your own variant: |
|
|
```bash |
|
|
git clone https://huggingface.co/datasets/DeepMostInnovations/saas-sales-conversations |
|
|
python train.py --dataset your_data.csv --model_path custom_model --timesteps 200000 |
|
|
``` |
|
|
|
|
|
## 📄 License & Citation |
|
|
|
|
|
### License |
|
|
MIT License - Feel free to use and modify for your needs. |
|
|
|
|
|
### Citation |
|
|
If you use this model in your research or applications, please cite: |
|
|
|
|
|
```bibtex |
|
|
@article{nandakishor2025salesrlagent, |
|
|
title={SalesRLAgent: A Reinforcement Learning Approach for Real-Time Sales Conversion Prediction and Optimization}, |
|
|
author={Nandakishor, M}, |
|
|
journal={arXiv preprint arXiv:2503.23303}, |
|
|
year={2025}, |
|
|
url={https://arxiv.org/abs/2503.23303} |
|
|
} |
|
|
``` |
|
|
|
|
|
## 🔗 Links & Resources |
|
|
|
|
|
- **PyPI Package**: [https://pypi.org/project/deepmost/](https://pypi.org/project/deepmost/) |
|
|
- **GitHub Repository**: [https://github.com/DeepMostInnovations/deepmost](https://github.com/DeepMostInnovations/deepmost) |
|
|
- **Research Paper**: [https://arxiv.org/abs/2503.23303](https://arxiv.org/abs/2503.23303) |
|
|
- **Training Dataset**: [https://huggingface.co/datasets/DeepMostInnovations/saas-sales-conversations](https://huggingface.co/datasets/DeepMostInnovations/saas-sales-conversations) |
|
|
- **Documentation**: [GitHub README](https://github.com/DeepMostInnovations/deepmost/blob/main/README.md) |
|
|
- **Support**: [email protected] |
|
|
|
|
|
--- |
|
|
|
|
|
**Focus on what matters: understanding how each conversation turn impacts your sales success.** 🎯 |
|
|
|
|
|
Made with ❤️ by [DeepMost Innovations](https://www.deepmostai.com/) |
