Update README.md

README.md

@@ -49,157 +49,16 @@ This is a reinforcement learning model trained to predict real-time sales conver
 
 ```bash
 pip install azure-openai stable-baselines3 numpy torch huggingface_hub
+git lfs install
+git clone https://huggingface.co/DeepMostInnovations/sales-conversion-model-reinf-learning
+%cd sales-conversion-model-reinf-learning
 ```
 
 
-## Complete Inference Code 
+## Run
 
-```python
-import os
-import numpy as np
-import torch
-import torch.nn as nn
-from openai import AzureOpenAI
-from stable_baselines3 import PPO
-from stable_baselines3.common.torch_layers import BaseFeaturesExtractor
-from dataclasses import dataclass
-from typing import List, Dict
-from huggingface_hub import hf_hub_download
-# Azure OpenAI Configuration
-AZURE_OPENAI_API_KEY = os.getenv("AZURE_OPENAI_API_KEY")
-AZURE_OPENAI_ENDPOINT = os.getenv("AZURE_OPENAI_ENDPOINT")
-AZURE_EMBEDDING_DEPLOYMENT = os.getenv("AZURE_EMBEDDING_DEPLOYMENT", "text-embedding-3-large")
-
-# Initialize Azure OpenAI client
-openai_client = AzureOpenAI(
-    api_key=AZURE_OPENAI_API_KEY,
-    api_version="2023-05-15",
-    azure_endpoint=AZURE_OPENAI_ENDPOINT
-)
-model_path = hf_hub_download(
-    repo_id="DeepMostInnovations/sales-conversion-model-reinf-learning",
-    filename="sales_model.zip"
-)
-# Check for GPU
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-# Custom Linear Layer class
-class CustomLN(BaseFeaturesExtractor):
-    def __init__(self, observation_space, features_dim: int = 64):
-        super().__init__(observation_space, features_dim)
-        n_input_channels = observation_space.shape[0]
-        self.ln = nn.Sequential(
-            nn.Linear(n_input_channels, 512),
-            nn.ReLU(),
-            nn.Linear(512, 256),
-            nn.ReLU(),
-            nn.Linear(256, features_dim),
-            nn.ReLU(),
-        ).to(device)
-        
-    def forward(self, observations: torch.Tensor) -> torch.Tensor:
-        return self.ln(observations)
-
-@dataclass
-class SalesAgent:
-    model_path: str
-    
-    def __init__(self, model_path: str):
-        self.model_path = model_path
-        self.expected_embedding_dim = 3072
-        
-        # Load RL model
-        policy_kwargs = dict(
-            activation_fn=nn.ReLU,
-            net_arch=[dict(pi=[128, 64], vf=[128, 64])],
-            features_extractor_class=CustomLN,
-            features_extractor_kwargs=dict(features_dim=64)
-        )
-        
-        self.model = PPO.load(
-            model_path, 
-            device=device,
-            custom_objects={"policy_kwargs": policy_kwargs}
-        )
-        
-    def get_embedding(self, text: str) -> np.ndarray:
-        """Get embedding using Azure OpenAI"""
-        response = openai_client.embeddings.create(
-            model=AZURE_EMBEDDING_DEPLOYMENT,
-            input=text
-        )
-        
-        embedding = np.array(response.data[0].embedding, dtype=np.float32)
-        
-        # Adjust to expected dimension if needed
-        if len(embedding) > self.expected_embedding_dim:
-            # Average pooling
-            embedding = np.array([
-                np.mean(embedding[i:i+len(embedding)//self.expected_embedding_dim])
-                for i in range(0, len(embedding), len(embedding)//self.expected_embedding_dim)
-            ][:self.expected_embedding_dim])
-        elif len(embedding) < self.expected_embedding_dim:
-            # Pad with zeros
-            embedding = np.pad(embedding, (0, self.expected_embedding_dim - len(embedding)))
-        
-        return embedding
-    
-    def create_state_vector(self, conversation_text: str, turn_number: int) -> np.ndarray:
-        """Create state vector for RL model"""
-        embedding = self.get_embedding(conversation_text)
-        
-        # Simple metrics
-        metrics = np.array([0.5, 0.5, turn_number, 0.5, min(1.0, turn_number / 20)], dtype=np.float32)
-        turn_info = np.array([turn_number], dtype=np.float32)
-        prob_history = np.zeros(10, dtype=np.float32)
-        
-        return np.concatenate([embedding, metrics, turn_info, prob_history])
-    
-    def predict_conversion(self, conversation_text: str, turn_number: int) -> float:
-        """Predict conversion probability"""
-        state_vector = self.create_state_vector(conversation_text, turn_number)
-        
-        with torch.no_grad():
-            action, _ = self.model.predict(state_vector, deterministic=True)
-            probability = float(action[0])
-            
-        return max(0.0, min(1.0, probability))
-    
-    def analyze_conversation(self, conversation: List[Dict[str, str]]) -> Dict:
-        """Analyze a full conversation"""
-        results = []
-        conversation_text = ""
-        
-        for i, turn in enumerate(conversation):
-            conversation_text += f"{turn['role']}: {turn['content']}\n"
-            
-            if turn['role'] == 'assistant':
-                probability = self.predict_conversion(conversation_text, i // 2 + 1)
-                results.append({
-                    'turn_number': i // 2 + 1,
-                    'response': turn['content'],
-                    'probability': probability
-                })
-        
-        final_probability = results[-1]['probability'] if results else 0.0
-        
-        return {
-            'conversation_results': results,
-            'final_probability': final_probability,
-            'summary': f"Predicted final conversion: {final_probability*100:.1f}%"
-        }
+```bash
 
-# Example usage
-if __name__ == "__main__":
-    agent = SalesAgent(model_path)
-    
-    conversation = [
-        {"role": "user", "content": "I'm looking for a project management tool."},
-        {"role": "assistant", "content": "Thanks! How large is your team?"}
-    ]
-    
-    results = agent.analyze_conversation(conversation)
-    print(results['summary'])
 ```