multi class

app.py

@@ -4,6 +4,7 @@ from tool import rival_product
 from graphrag import reasoning
 from knowledge import graph
 from pii import derisk
+from classify import bucket
 
 # Define the Google Analytics script
 head = """
@@ -48,6 +49,20 @@ Links:
     btn_recommend.click(fn=rbc_product, inputs=in_verbatim, outputs=out_product)
 
     gr.Markdown("""
+Benefits of a Product Recommender System
+====================
+- Increased Sales & Revenue
+Personalized recommendations drive higher conversion rates and average order value.
+
+- Enhanced Customer Experience
+Tailored suggestions make the shopping journey smoother and more relevant.
+
+- Customer Retention & Loyalty
+Relevant offers encourage repeat visits and build long-term loyalty.
+
+- Inventory Optimization
+Promotes underperforming products or clears surplus stock with strategic recommendations.
+
 Marketing
 ------------
 - GraphRAG: Models customer-product relationship networks for next-best-action predictions
@@ -79,6 +94,21 @@ Risk & Audit
     btn_recommend=gr.Button("Recommend")
     btn_recommend.click(fn=rival_product, inputs=in_verbatim, outputs=out_product)
 
+    gr.Markdown("""
+Benefits of a Competitor Product Recommender
+=================
+- Improved Customer Retention
+Prevents drop-offs by offering similar alternatives when a preferred product is unavailable or suboptimal.
+
+- Increased Conversion Rates
+Captures potential lost sales by guiding customers toward viable substitutes.
+
+- Builds Trust and Transparency
+Demonstrates a customer-first approach by recommending the best-fit product—even if it’s not your own.
+
+- Portfolio Optimization
+Helps businesses learn which competitor features customers prefer, guiding product development and pricing.
+    """)
   with gr.Tab("graphrag"):
     gr.Markdown("""
     Objective: Create a Marketing Plan based on persona.
@@ -134,6 +164,15 @@ Low APR and great customer service. I would highly recommend if you’re looking
     btn_recommend = gr.Button("Reasoning")
     btn_recommend.click(fn=reasoning, inputs=[in_verbatim, in_question], outputs=out_product)
 
+    gr.Markdown("""
+Benefits of a Marketing Campaign Generator
+===============
+- Accelerated Campaign Launches
+Quickly generates tailored campaigns, reducing go-to-market time from weeks to hours.
+
+- Improved Targeting & Personalization
+Uses customer data and behavior to craft messages that resonate with specific segments.
+        """)
 
   with gr.Tab("Knowledge Graph"):
     gr.Markdown("""
@@ -154,6 +193,21 @@ Low APR and great customer service. I would highly recommend if you’re looking
     btn_recommend = gr.Button("Graph It!")
     btn_recommend.click(fn=graph, inputs=in_verbatim, outputs=out_product)
 
+    gr.Markdown("""
+Benefits of a Knowledge Graph
+============
+- Smarter Data Relationships
+Connects siloed data across domains to create a holistic, contextual view.
+
+- Improved Search & Discovery
+Enables semantic search—understanding meaning, not just keywords.
+
+- Enhanced Decision-Making
+Surfaces hidden patterns and relationships for better analytics and insights.
+
+- Data Reusability
+Once created, knowledge graphs can be repurposed across multiple use cases (e.g., search, recommendation, fraud detection).
+          """)
 
   with gr.Tab("pii masking"):
     gr.Markdown("""
@@ -180,5 +234,57 @@ Low APR and great customer service. I would highly recommend if you’re looking
     )
     btn_recommend = gr.Button("Mask PII")
     btn_recommend.click(fn=derisk, inputs=in_verbatim, outputs=out_product)
+    gr.Markdown("""
+Benefits of Entity Removal
+==================
+- Data Privacy & Compliance
+Ensures sensitive information (names, emails, phone numbers, etc.) is anonymized to comply with GDPR, HIPAA, or other regulations.
+
+- Improved Data Quality
+Removes noise (e.g., irrelevant names or addresses) to make datasets cleaner and more usable for modeling or analysis.
+
+- Enhanced Focus for NLP Models
+Allows downstream tasks (like sentiment analysis or topic modeling) to focus on content rather than personal identifiers.
+    """)
 
+
+  with gr.Tab("multi class classification"):
+    gr.Markdown("""
+    Objective: Classify customer feedback into product bucket
+    ================================================
+    """)
+    in_verbatim = gr.Textbox(label="Customer Feedback")
+    out_product = gr.Textbox(label="Classification")
+
+    gr.Examples(
+      [
+        [
+        """
+"The online portal makes managing my mortgage payments so convenient."
+;"RBC offer great mortgage for my home with competitive rate thank you";
+"Low interest rate compared to other cards I’ve used. Highly recommend for responsible spenders.";
+"The mobile check deposit feature saves me so much time. Banking made easy!";
+"Affordable premiums with great coverage. Switched from my old provider and saved!"
+        """
+          ]
+      ],
+      [in_verbatim]
+    )
+    btn_recommend = gr.Button("Classify")
+    btn_recommend.click(fn=bucket, inputs=in_verbatim, outputs=out_product)
+    gr.Markdown("""
+Benefits of Multi Class Classification
+==================
+- Precision Decision-Making
+Automates complex categorization tasks (e.g., loan risk tiers, transaction types) with >90% accuracy, reducing human bias.
+
+- Operational Efficiency
+Processes 10,000+ transactions/cases per minute vs. hours manually (e.g., JP Morgan’s COiN platform reduced 360k loan doc hours to seconds).
+
+- Risk Mitigation
+Proactively flags 5+ fraud types (identity theft, money laundering) with 40% fewer false positives than rule-based systems.
+
+- Regulatory Compliance
+Auto-classifies documents for FINRA/SEC audits (e.g., Morgan Stanley uses NLP to categorize 3M+ annual communications into 50+ compliance buckets).
+    """)
 demo.launch(allowed_paths=["./"])

classify.py

@@ -0,0 +1,167 @@
+from typing import List, Iterable, Optional
+from pydantic import BaseModel, ValidationInfo, model_validator, Field,  field_validator
+import instructor
+import openai
+import asyncio
+import os
+
+
+
+from groq import AsyncGroq
+# Initialize with API key
+client = AsyncGroq(api_key=os.getenv("GROQ_API_KEY"))
+
+# Enable instructor patches for Groq client
+client = instructor.from_groq(client)
+"""
+import openai
+client = instructor.from_openai(
+    openai.AsyncOpenAI(
+        base_url="http://localhost:11434/v1",
+        api_key="ollama",
+    ),
+    mode=instructor.Mode.JSON,
+)
+"""
+llm = 'llama-3.1-8b-instant' if os.getenv("GROQ_API_KEY") else "deepseek-r1"
+
+
+class Tag(BaseModel):
+
+    chain_of_thought:List[str]= Field(default_factory=list, description="the chain of thought led to the prediction", examples=["Let's think step by step. the customer explicitly mention donation, and there is a tag name with donation, tag the text with donation"])
+    name: str
+    id: int= Field(..., description="id for the specific tag")
+    confidence: float = Field(
+        default=0.5,
+        ge=0,
+        le=1,
+        description="The confidence of the prediction for name and id, 0 is low, 1 is high",examples=[0.5,0.1,0.9]
+    )
+
+    @field_validator('confidence', mode="after")
+    @classmethod
+    def high_confidence(cls, c:float):
+      "keep tag with confidence 0.6 or above"
+      if c < 0.6:
+          raise ValueError(f"low confidence `{c}` ")
+      return c
+
+    @model_validator(mode="after")
+    def validate_ids(self, info: ValidationInfo):
+        context = info.context
+        if context:
+            tags: List[Tag] = context.get("tags")
+
+            assert self.id in {
+                tag.id for tag in tags
+            }, f"Tag ID {self.id} not found in context"
+
+            assert self.name.lower() in {
+                tag.name.lower() for tag in tags
+            }, f"Tag name {self.name} not found in context"
+        return self
+
+
+
+class TagWithInstructions(Tag):
+    instructions: str
+
+
+class TagRequest(BaseModel):
+    texts: List[str]
+    tags: List[TagWithInstructions]
+
+
+class TagResponse(BaseModel):
+    texts: List[str]
+    predictions: List[Optional[Iterable[Tag]]]=Field(...,default_factory=list)
+
+sem = asyncio.Semaphore(2)
+
+async def tag_single_request(text: str, tags: List[Tag]) -> Iterable[Tag]:
+  allowed_tags = [(tag.id, tag.name) for tag in tags]
+  allowed_tags_str = ", ".join([f"`{tag}`" for tag in allowed_tags])
+
+  async with sem:
+
+    try:
+      result = await client.chat.completions.create(
+        model=llm, #"gpt-4o-mini","deepseek-r1", #"llama3.2"
+        temperature=0.3,
+        max_retries=3,
+        messages=[
+          {
+            "role": "system",
+            "content": """You are a world-class text tagging system for customer feedback in the banking industry to classify banking product/services. 
+  """
+          },
+          {"role": "user", "content": f"""Create minimum multiple Tag according to instruction most appropriate for the following text: `{text}`
+            ### Instruction:
+            Here are the allowed Tag(id, name), do not use any other Tag than these: {allowed_tags_str}
+            Tag the name based on fact stated and directly mention in the text. Do not guess the name, Do not tag if tag not mention in the text. Do not use implication.
+            Calculate the newly created Tag's confidence that Tag  fit to the text
+            
+            For each question, show your step-by-step thinking under 'chain_of_thought' in list of string, then clearly state your final answer under 'name'.
+            """ },
+
+        ],
+        response_model=Iterable[Tag],
+        validation_context={"tags": tags},
+      )
+      return result
+    except Exception as e:
+      print(e)
+
+
+async def tag_request(request: TagRequest) -> TagResponse:
+  predictions = await asyncio.gather(
+    *[tag_single_request(text, request.tags) for text in request.texts]
+  )
+  pred_dedup=[]
+  for tags in predictions:
+    if tags is not None:
+      dedup=[]
+      #filter(lambda x: x.confidence > 0.7, tags)
+      tags_s=sorted(tags, key=lambda x: (x.name, x.confidence))
+      if len(tags_s)>0:
+        dedup.append(tags_s[0])
+        for j in range(1,len(tags_s)):
+          if tags_s[j-1].name!=tags_s[j].name:
+            dedup.append(tags_s[j])
+
+      pred_dedup.append(dedup)
+    else:
+      pred_dedup.append(None)
+
+  return TagResponse(
+    texts=request.texts,
+    predictions=pred_dedup,
+  )
+
+
+tags = [
+    TagWithInstructions(id=0, name="online", instructions="text related to online banking"),
+    TagWithInstructions(id=1, name="card", instructions="text related to credit card"),
+    TagWithInstructions(id=2, name="cars", instructions="auto finance"),
+    TagWithInstructions(id=3, name="mortgage", instructions="home mortgage"),
+    TagWithInstructions(id=4, name="insurance", instructions="insurance"),
+]
+
+
+texts = """
+"The online portal makes managing my mortgage payments so convenient."
+;"RBC offer great mortgage for my home with competitive rate thank you";
+"Low interest rate compared to other cards I’ve used. Highly recommend for responsible spenders.";
+"The mobile check deposit feature saves me so much time. Banking made easy!";
+"Affordable premiums with great coverage. Switched from my old provider and saved!"
+"""
+
+def bucket(texts):
+  texts=texts.split(";")
+  request = TagRequest(texts=texts, tags=tags)
+
+  response = asyncio.run(tag_request(request))
+  return response.model_dump_json(indent=2)
+
+if __name__=="__main__":
+  print(bucket(texts))

pii.py

@@ -1,14 +1,8 @@
 import os
 
 import instructor
-from groq import Groq
 from pydantic import BaseModel
 
-# Initialize with API key
-client = Groq(api_key=os.getenv("GROQ_API_KEY"))
-
-# Enable instructor patches for Groq client
-client = instructor.from_groq(client)
 """
 client = instructor.from_openai(
     OpenAI(
@@ -18,6 +12,13 @@ client = instructor.from_openai(
     mode=instructor.Mode.JSON,
 )
 """
+from groq import Groq
+# Initialize with API key
+client = Groq(api_key=os.getenv("GROQ_API_KEY"))
+
+# Enable instructor patches for Groq client
+client = instructor.from_groq(client)
+
 llm = 'llama-3.1-8b-instant' if os.getenv("GROQ_API_KEY") else "llama3.2"
 
 
@@ -34,7 +35,7 @@ class PIIExtraction(BaseModel):
   private_data: list[PIIData]
   chain_of_thought: str
 
-  def scrub_data(self, content):
+  def sanitize(self, content):
     """
     Iterates over the private data and replaces the value with a placeholder in the form of
     <{data_type}_{i}>
@@ -84,4 +85,4 @@ if __name__ == '__main__':
 
   print(derisk(ESSAY))
   # print(pii_leak.model_dump_json(indent=2))
-  # print(pii_leak.scrub_data(ESSAY))
+  # print(pii_leak.sanitize(ESSAY))