Upload 10 files

AI Customer Behavior Agent/README.md

@@ -0,0 +1,28 @@
+# Customer Agent RL
+
+## Overview
+This project simulates an advanced customer behavior analysis using an RL agent (Deep Q-Network) based on a comprehensive synthetic dataset covering multiple sectors (Retail, E-commerce, Banking, Telecom, Travel). The dataset (30,000+ records) is generated using research insights and inserted into a local MongoDB database.
+
+## File Structure
+[AI_CUSTOMER_BEHAVIOR/
+│── data/
+│   └── customers.csv            # Generated synthetic customer records (30,000+)
+│── models/
+│   └── dqn_model.pth            # Saved RL model weights after training
+│── src/
+│   ├── generate_data.py         # Script to generate a comprehensive multi-sector dataset
+│   ├── insert_data.py           # Script to load the CSV and insert data into MongoDB
+│   ├── rl_agent.py              # Advanced Deep Q-Network (DQN) agent implementation (O³ model style)
+│   └── dashboard.py             # Streamlit dashboard to visualize customer behavior insights
+│── notebooks/
+│   └── exploration.ipynb        # Notebook for exploratory analysis and experiments
+│── requirements.txt             # Dependencies for the project
+│── config.yaml                  # Configuration file for settings (MongoDB URI, hyperparameters, etc.)
+└── README.md                    # Documentation and instructions
+
+
+## Setup & Usage
+
+1. **Install Dependencies**  
+   ```bash
+   pip install -r requirements.txt

AI Customer Behavior Agent/app.py

@@ -0,0 +1,88 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import random
+import matplotlib.pyplot as plt
+from sklearn.preprocessing import MinMaxScaler
+from backend.src.dqn_agent import AdvancedDQNAgent
+
+st.set_page_config(page_title="Next (AI): Customer", layout="wide")
+st.title("Next AI: Product Recommendation Agent")
+st.markdown("Chat with nExT(AI) to get real-time customer targeting recommendations. Type a query (e.g., 'Show me discount recommendations') and nExT(AI) will reply with the corresponding customer table.")
+
+# Initialize session state for chat history
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
+
+# Helper function to load and preprocess data
+@st.cache_data(show_spinner=False)
+def load_data():
+    df = pd.read_csv("data\\customers.csv")
+    return df
+
+def preprocess_data(df):
+    churn_mapping = {"Low": 0, "Medium": 1, "High": 2}
+    df['ChurnRiskEncoded'] = df['ChurnRisk'].map(churn_mapping)
+    features = df[['Age', 'Income', 'PurchaseFrequency', 'AvgSpend', 'ChurnRiskEncoded']].values
+    scaler = MinMaxScaler()
+    features = scaler.fit_transform(features)
+    return features
+
+# Load and preprocess data
+df = load_data()
+states = preprocess_data(df)
+
+# Setup RL agent (state vector of 5 features; actions: 0: Discount, 1: Recommend Product, 2: No Action)
+state_size = states.shape[1]
+action_size = 3
+agent = AdvancedDQNAgent(state_size, action_size)
+
+# For demonstration, run the agent on all customers to compute recommendations.
+recommendations = [agent.act(state) for state in states]
+df['Recommendation'] = recommendations
+
+# Group recommendations
+discount_df = df[df['Recommendation'] == 0]
+product_df = df[df['Recommendation'] == 1]
+no_action_df = df[df['Recommendation'] == 2]
+
+# Define a simple function to process user queries
+def process_query(query):
+    query_lower = query.lower()
+    if "discount" in query_lower:
+        response = "Here are the customers recommended for a discount (Action 0):"
+        table = discount_df[['CustomerID', 'Age', 'Income', 'PurchaseFrequency', 'AvgSpend', 'ChurnRisk']]
+    elif "product" in query_lower:
+        response = "Here are the customers recommended for a product suggestion (Action 1):"
+        table = product_df[['CustomerID', 'Age', 'Income', 'PurchaseFrequency', 'AvgSpend', 'ChurnRisk']]
+    elif "no action" in query_lower:
+        response = "Here are the customers for whom no specific action is recommended (Action 2):"
+        table = no_action_df[['CustomerID', 'Age', 'Income', 'PurchaseFrequency', 'AvgSpend', 'ChurnRisk']]
+    elif "all" in query_lower or "recommendation" in query_lower:
+        response = "Here are all customer recommendations:"
+        table = df[['CustomerID', 'Age', 'Income', 'PurchaseFrequency', 'AvgSpend', 'ChurnRisk', 'Recommendation']]
+    else:
+        response = "I'm sorry, I didn't understand that. Please ask for discount, product, or no action recommendations."
+        table = None
+    return response, table
+
+# Display chat history
+for chat in st.session_state.chat_history:
+    if chat["role"] == "user":
+        st.markdown(f"**User:** {chat['message']}")
+    else:
+        st.markdown(f"**nExT(AI):** {chat['message']}")
+        if chat.get("table") is not None:
+            st.table(chat["table"])
+
+# Input for new message
+user_input = st.text_input("Type your message here and press Enter:")
+
+if user_input:
+    # Append user's message to chat history
+    st.session_state.chat_history.append({"role": "user", "message": user_input})
+    # Process the query and get reply
+    reply_text, reply_table = process_query(user_input)
+    st.session_state.chat_history.append({"role": "agent", "message": reply_text, "table": reply_table})
+    # Clear input by simply relying on Streamlit's reactivity (the text input resets on script re-run)
+    # Note: Without experiment

AI Customer Behavior Agent/backend/src/dashboard.py

@@ -0,0 +1,64 @@
+# File: src/dashboard.py
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+from pymongo import MongoClient
+
+# MongoDB settings (can also be loaded from config.yaml)
+MONGO_URI = "mongodb://localhost:27017/"
+DB_NAME = "customer_db"
+COLLECTION_NAME = "customers"
+
+def load_data():
+    client = MongoClient(MONGO_URI)
+    db = client[DB_NAME]
+    collection = db[COLLECTION_NAME]
+    data = list(collection.find({}, {"_id": 0}))
+    return pd.DataFrame(data)
+
+st.title("📊 Advanced Multi-Sector Customer Behavior Dashboard")
+
+df = load_data()
+
+# Sidebar Filters
+st.sidebar.header("Filters")
+age_min, age_max = st.sidebar.slider("Age Range", 18, 80, (25, 60))
+income_min, income_max = st.sidebar.slider("Income Range", 20000, 150000, (30000, 100000))
+sectors = st.sidebar.multiselect("Select Sector(s)", options=df["Sector"].unique(), default=df["Sector"].unique())
+
+filtered_df = df[
+    (df["Age"] >= age_min) & (df["Age"] <= age_max) &
+    (df["Income"] >= income_min) & (df["Income"] <= income_max) &
+    (df["Sector"].isin(sectors))
+]
+
+st.write(f"### Showing {len(filtered_df)} records based on filters")
+st.dataframe(filtered_df.head(50))
+
+# Plot: Distribution by Sector
+st.subheader("Customer Distribution by Sector")
+sector_counts = filtered_df["Sector"].value_counts()
+fig, ax = plt.subplots()
+sector_counts.plot(kind="bar", ax=ax)
+st.pyplot(fig)
+
+# Sector-specific insights
+st.subheader("Sector-specific Insights")
+for sector in sectors:
+    st.write(f"**{sector}**")
+    sector_data = filtered_df[filtered_df["Sector"] == sector]
+    if sector in ["Retail", "E-commerce"]:
+        avg_rating = sector_data["AvgRating"].mean() if "AvgRating" in sector_data.columns else None
+        st.write(f"Average Product Rating: {avg_rating:.2f}" if avg_rating else "No rating data")
+    elif sector == "Banking":
+        avg_credit = sector_data["CreditScore"].mean() if "CreditScore" in sector_data.columns else None
+        st.write(f"Average Credit Score: {avg_credit:.2f}" if avg_credit else "No credit data")
+    elif sector == "Telecom":
+        avg_data = sector_data["MonthlyDataGB"].mean() if "MonthlyDataGB" in sector_data.columns else None
+        st.write(f"Average Monthly Data Usage: {avg_data:.2f} GB" if avg_data else "No telecom data")
+    elif sector == "Travel":
+        avg_trips = sector_data["TripsPerYear"].mean() if "TripsPerYear" in sector_data.columns else None
+        st.write(f"Average Trips per Year: {avg_trips:.2f}" if avg_trips else "No travel data")
+    st.write("---")
+
+st.write("Dashboard powered by **Streamlit, MongoDB & an advanced multi-sector synthetic dataset**")

AI Customer Behavior Agent/backend/src/dqn_agent.py

@@ -0,0 +1,103 @@
+# File: src/dqn_agent.py
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import random
+import numpy as np
+from collections import deque
+
+# Dueling DQN network architecture for state‑action value estimation
+class DuelingDQN(nn.Module):
+    def __init__(self, state_size, action_size):
+        super(DuelingDQN, self).__init__()
+        self.fc1 = nn.Linear(state_size, 128)
+        self.fc2 = nn.Linear(128, 128)
+        # Value stream
+        self.value_stream = nn.Sequential(
+            nn.Linear(128, 64),
+            nn.ReLU(),
+            nn.Linear(64, 1)
+        )
+        # Advantage stream
+        self.advantage_stream = nn.Sequential(
+            nn.Linear(128, 64),
+            nn.ReLU(),
+            nn.Linear(64, action_size)
+        )
+    
+    def forward(self, x):
+        x = torch.relu(self.fc1(x))
+        x = torch.relu(self.fc2(x))
+        value = self.value_stream(x)
+        advantage = self.advantage_stream(x)
+        # Combine streams to get Q-values
+        q_values = value + (advantage - advantage.mean(dim=1, keepdim=True))
+        return q_values
+
+class AdvancedDQNAgent:
+    def __init__(self, state_size, action_size, device="cpu"):
+        self.state_size = state_size
+        self.action_size = action_size
+        self.device = device
+        
+        self.memory = deque(maxlen=10000)
+        self.gamma = 0.99  # discount factor
+        self.epsilon = 1.0  # exploration rate
+        self.epsilon_min = 0.01
+        self.epsilon_decay = 0.995
+        self.learning_rate = 0.001
+        self.batch_size = 64
+        
+        self.policy_net = DuelingDQN(state_size, action_size).to(device)
+        self.target_net = DuelingDQN(state_size, action_size).to(device)
+        self.update_target_network()
+        self.optimizer = optim.Adam(self.policy_net.parameters(), lr=self.learning_rate)
+        self.criterion = nn.MSELoss()
+
+    def update_target_network(self):
+        self.target_net.load_state_dict(self.policy_net.state_dict())
+
+    def act(self, state):
+        if np.random.rand() <= self.epsilon:
+            return random.randrange(self.action_size)
+        state_tensor = torch.FloatTensor(state).unsqueeze(0).to(self.device)
+        with torch.no_grad():
+            q_values = self.policy_net(state_tensor)
+        return int(torch.argmax(q_values).item())
+    
+    def remember(self, state, action, reward, next_state, done):
+        self.memory.append((state, action, reward, next_state, done))
+    
+    def replay(self):
+        if len(self.memory) < self.batch_size:
+            return
+        
+        batch = random.sample(self.memory, self.batch_size)
+        states, actions, rewards, next_states, dones = zip(*batch)
+        states = torch.FloatTensor(states).to(self.device)
+        actions = torch.LongTensor(actions).unsqueeze(1).to(self.device)
+        rewards = torch.FloatTensor(rewards).unsqueeze(1).to(self.device)
+        next_states = torch.FloatTensor(next_states).to(self.device)
+        dones = torch.FloatTensor(dones).unsqueeze(1).to(self.device)
+        
+        # Compute current Q-values
+        current_q = self.policy_net(states).gather(1, actions)
+        # Double DQN: select next action using policy net, evaluate with target net
+        next_actions = torch.argmax(self.policy_net(next_states), dim=1, keepdim=True)
+        next_q = self.target_net(next_states).gather(1, next_actions)
+        target_q = rewards + (self.gamma * next_q * (1 - dones))
+        
+        loss = self.criterion(current_q, target_q.detach())
+        self.optimizer.zero_grad()
+        loss.backward()
+        self.optimizer.step()
+        
+        if self.epsilon > self.epsilon_min:
+            self.epsilon *= self.epsilon_decay
+            
+    def save(self, path):
+        torch.save(self.policy_net.state_dict(), path)
+    
+    def load(self, path):
+        self.policy_net.load_state_dict(torch.load(path))
+        self.update_target_network()

AI Customer Behavior Agent/backend/src/generate_data.py

@@ -0,0 +1,64 @@
+# File: src/generate_data.py
+import pandas as pd
+import random
+import uuid
+from faker import Faker
+
+fake = Faker()
+
+def generate_customer_record():
+    customer_id = str(uuid.uuid4())
+    age = random.randint(18, 80)
+    gender = random.choice(["Male", "Female", "Other"])
+    income = round(random.uniform(20000, 150000), 2)
+    purchase_frequency = random.randint(1, 100)
+    avg_spend = round(random.uniform(10, 2000), 2)
+    churn_risk = random.choice(["Low", "Medium", "High"])
+    
+    # Sector and sector‑specific details
+    sector = random.choice(["Retail", "E-commerce", "Banking", "Telecom", "Travel"])
+    if sector in ["Retail", "E-commerce"]:
+        product_category = random.choice(["Electronics", "Fashion", "Home", "Sports", "Beauty"])
+        avg_rating = round(random.uniform(1, 5), 1)
+        cart_abandon_rate = round(random.uniform(0, 0.5), 2)
+        extra = {"Sector": sector, "ProductCategory": product_category,
+                 "AvgRating": avg_rating, "CartAbandonRate": cart_abandon_rate}
+    elif sector == "Banking":
+        credit_score = random.randint(300, 850)
+        num_transactions = random.randint(10, 200)
+        extra = {"Sector": sector, "CreditScore": credit_score,
+                 "NumTransactions": num_transactions}
+    elif sector == "Telecom":
+        monthly_data = round(random.uniform(0.5, 50), 2)
+        call_minutes = random.randint(100, 3000)
+        extra = {"Sector": sector, "MonthlyDataGB": monthly_data,
+                 "CallMinutes": call_minutes}
+    elif sector == "Travel":
+        trips_per_year = random.randint(0, 15)
+        loyalty_tier = random.choice(["Bronze", "Silver", "Gold", "Platinum"])
+        extra = {"Sector": sector, "TripsPerYear": trips_per_year,
+                 "LoyaltyTier": loyalty_tier}
+    else:
+        extra = {"Sector": sector}
+    
+    record = {
+        "CustomerID": customer_id,
+        "Age": age,
+        "Gender": gender,
+        "Income": income,
+        "PurchaseFrequency": purchase_frequency,
+        "AvgSpend": avg_spend,
+        "ChurnRisk": churn_risk
+    }
+    record.update(extra)
+    return record
+
+def generate_dataset(num_records=30000):
+    records = [generate_customer_record() for _ in range(num_records)]
+    df = pd.DataFrame(records)
+    # Save CSV to the data folder
+    df.to_csv("data\\customers.csv", index=False)
+    print(f" Generated {num_records} customer records and saved to ../data/customers.csv")
+
+if __name__ == "__main__":
+    generate_dataset()

AI Customer Behavior Agent/backend/src/insert_data.py

@@ -0,0 +1,23 @@
+# File: src/insert_data.py
+import pandas as pd
+from pymongo import MongoClient
+
+# Configuration (can also be set via config.yaml)
+MONGO_URI = "mongodb://localhost:27017/"
+DB_NAME = "customer_db"
+COLLECTION_NAME = "customers"
+
+def insert_data():
+    client = MongoClient(MONGO_URI)
+    db = client[DB_NAME]
+    collection = db[COLLECTION_NAME]
+    
+    # Load data from CSV
+    df = pd.read_csv("data\\customers.csv")
+    records = df.to_dict(orient="records")
+    collection.delete_many({})  
+    collection.insert_many(records)
+    print(f" Inserted {len(records)} records into MongoDB collection '{COLLECTION_NAME}' in DB '{DB_NAME}'.")
+
+if __name__ == "__main__":
+    insert_data()

AI Customer Behavior Agent/requirements.txt

@@ -0,0 +1,6 @@
+pandas
+faker
+pymongo
+torch
+streamlit
+matplotlib