README.md

metadata

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
      assistant: Thank you for your interest. How can I help you today?
    example_title: Early Stage Prospect
  - text: |-
      user: What's your pricing?
      assistant: Our plans start at $10/user/month
    example_title: Price Discussion

Sales Conversation Analysis Model - Turn-by-Turn Prediction

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
Author: Nandakishor M
Published: arXiv:2503.23303

🚀 Quick Start with This Model

Installation

# Requires Python 3.11 for optimal compatibility
pip install deepmost[gpu]  # Recommended for LLM features

Method 1: Direct URL Download (Easiest)

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)

git lfs install
git clone https://huggingface.co/DeepMostInnovations/sales-conversion-model-reinf-learning
cd sales-conversion-model-reinf-learning

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

# 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

# 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

# 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

# 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

# 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

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

# 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

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:

{
    '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

# 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:

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:

@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/
• GitHub Repository: https://github.com/DeepMostInnovations/deepmost
• Research Paper: https://arxiv.org/abs/2503.23303
• Training Dataset: https://huggingface.co/datasets/DeepMostInnovations/saas-sales-conversations
• Documentation: GitHub README
• Support: [email protected]

---

Focus on what matters: understanding how each conversation turn impacts your sales success. 🎯

Made with ❤️ by DeepMost Innovations