adding app to huggingface space

README.md

@@ -1,5 +1,5 @@
 ---
-title: GRC Framework
+title: AI Analysis and GRC Framework Application
 emoji: 📊
 colorFrom: yellow
 colorTo: purple
@@ -10,4 +10,14 @@ pinned: false
 license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## Introduction
+This project presents a comprehensive AI analysis tool integrated with the ChatGPT API, focusing on various aspects such as AI Audit, Sentiment Analysis, Toxicity Detection, Emotion Detection, and more. The application is designed to assist in Governance, Risk Management, and Compliance (GRC) frameworks, providing insightful AI-driven analysis.
+
+## Features
+- **AI Audit Analysis**: In-depth auditing capabilities for AI systems.
+- **Sentiment Analysis**: Evaluates sentiments with confidence scores and text snippets.
+- **Toxicity Detection**: Identifies and assesses toxic content.
+- **Emotion Detection**: Analyzes and reports on the emotional tone of text.
+- Additional analysis categories covering a wide range of AI applications.
+- Interactive web interface using Gradio.
+- Integration with OpenAI's ChatGPT API for robust AI analysis.

app.py

@@ -0,0 +1,220 @@
+
+import os
+import requests
+import gradio as gr
+requests.adapters.DEFAULT_TIMEOUT = 60
+import time
+import openai
+from openai import OpenAI
+from utils import ai_audit_analysis_categories, get_system_prompt, ANALYSIS_TYPES
+import json
+
+
+# Create Global Variables
+client = OpenAI(api_key= "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")
+
+global complete_chat_history, bot_last_message
+bot_last_message = "" 
+complete_chat_history = []
+
+
+# /////////////////// *****************************///////////////// Utitlity Functions
+#region Utility Functions
+
+# Function to update OpenAPI key the API key
+def update_api_key(new_api_key):
+    global client
+    if new_api_key.strip() != "":
+        client = OpenAI(api_key=new_api_key)
+    return "API Key updated successfully"
+
+
+def load_chatboat_last_message():
+    return bot_last_message
+
+def load_chatboat_complet_history():
+    complete_text = ""
+    for turn in complete_chat_history:
+        user_message, bot_message = turn
+        complete_text = f"{complete_text}\nUser: {user_message}\nAssistant: {bot_message}"
+    return complete_text
+
+
+def format_json_result_to_html(result):
+    formatted_result = ""
+    for key, value in result.items():
+        if isinstance(value, list):
+            formatted_result += f"<strong>{key.title()}:</strong><br>" + "<br>".join(value) + "<br><br>"
+        else:
+            formatted_result += f"<strong>{key.title()}:</strong> {value}<br>"
+    return formatted_result.strip()
+
+def format_json_result(result):
+    formatted_result = ""
+    for key, value in result.items():
+        if isinstance(value, list):
+            formatted_result += f"{key.title()}:\n" + "\n".join(value) + "\n\n"
+        else:
+            formatted_result += f"{key.title()}: {value}\n"
+    return formatted_result.strip()
+
+# Function to dynamically format the JSON result into Markdown format
+def format_result_to_markdown(result):
+    formatted_result = ""
+    for key, value in result.items():
+        formatted_result += f"**{key.title()}**: "
+        if isinstance(value, list):
+            formatted_result += "\n" + "\n".join(f"- {item}" for item in value) + "\n\n"
+        else:
+            formatted_result += f"{value}\n\n"
+    return formatted_result.strip()
+
+#endregion
+
+
+
+
+
+
+# /////////////////// *****************************///////////////// Conversation with Open Ai Chatboat
+#region Conversation with Open Ai Chatboat
+# A Normal call to OpenAI API '''
+def chat(system_prompt, user_prompt, model = 'gpt-3.5-turbo', temperature = 0):
+    response = client.chat.completions.create(
+    messages=[
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt}
+    ],
+    model="gpt-3.5-turbo",
+    )
+    
+    res = response.choices[0].message.content  
+    return res
+
+# Lets format the prompt from the chat_history so that its looks good on the UI
+def format_chat_prompt(message, chat_history, max_convo_length):
+    prompt = ""
+    for turn in chat_history[-max_convo_length:]:
+        user_message, bot_message = turn
+        prompt = f"{prompt}\nUser: {user_message}\nAssistant: {bot_message}"
+    prompt = f"{prompt}\nUser: {message}\nAssistant:"
+    return prompt
+
+
+# This function gets a message from user, passes it to chat gpt and return the output
+def get_response_from_chatboat(message,chat_history, max_convo_length=10):
+    global bot_last_message, complete_chat_history
+    formatted_prompt = format_chat_prompt(message, chat_history, max_convo_length)
+    bot_message = chat(system_prompt='You are a friendly chatbot. Generate the output for only the Assistant.',user_prompt=formatted_prompt)
+
+    chat_history.append((message, bot_message))
+    complete_chat_history.append((message, bot_message))
+    bot_last_message = bot_message
+    return "", chat_history
+
+#endregion
+
+
+
+def analyse_current_conversation(text, analysis_type):
+    
+    if(ANALYSIS_TYPES.get(analysis_type, None) is None):
+        return f"Analysis type {analysis_type} is not implemented yet, please choose another category"
+    
+    if not text:
+        return f"No text provided to analyze for {analysis_type}, please provide text or load from chatboat history"
+    
+    word_count = len(text.split())
+
+    if(word_count < 20 ):
+        return f" The text is too short to analyze for {analysis_type}, please provide a large text"
+
+    system_prompt = get_system_prompt(analysis_type)
+    text_to_analyze = text
+
+    response = client.chat.completions.create(
+    messages=[
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": text_to_analyze}
+    ],
+    model="gpt-3.5-turbo",
+    )
+    
+    analysis_result = response.choices[0].message.content  
+    print(analysis_result)
+    parsed_result = json.loads(analysis_result)
+
+    formated_json = format_result_to_markdown(parsed_result)
+
+    print(parsed_result)
+    # Your implementation for counting words and performing analysis
+    return formated_json
+
+
+
+
+
+#region UI Related Functions
+
+def update_dropdown(main_category):
+    # Get the subcategories based on the selected main category
+    subcategories = ai_audit_analysis_categories.get(main_category, [])
+    print(subcategories)
+    return gr.Dropdown(choices=subcategories, value=subcategories[0] if subcategories else None)
+
+
+def update_analysis_type(subcategory):
+    pass
+    print(subcategory)
+
+
+
+#endregion
+
+
+
+with gr.Blocks() as demo:
+
+    # Add a text field for the API key
+    api_key_field = gr.Textbox(label="Enter your Chatgpt OpenAI API Key")
+    update_api_key_btn = gr.Button("Update API Key")
+    update_api_key_btn.click(update_api_key, inputs=[api_key_field], outputs=[])
+
+    gr.Markdown("# AI Audit and GRC Framework!")
+
+    with gr.Tabs():
+        with gr.TabItem("AI Chatbot"):
+            gr.Markdown("## AI Chatbot")
+            chatbot = gr.Chatbot(height=600)
+            msg = gr.Textbox(label="Write something for the chatbot here")
+            clear = gr.ClearButton(components=[msg, chatbot], value="Clear console")
+            submit_btn = gr.Button("Submit")
+            submit_btn.click(get_response_from_chatboat, inputs=[msg, chatbot], outputs=[msg, chatbot])
+            msg.submit(get_response_from_chatboat, inputs=[msg, chatbot], outputs=[msg, chatbot])
+
+        with gr.TabItem("AI Analysis"):
+            gr.Markdown("## AI Analysis")
+            gr.Markdown("Load your chatbot text or write your own to  and analyze it")
+            text_field = gr.Textbox(label="Text to Process", interactive=True, lines=2)
+
+            # Radio button and dropdown list
+            initial_main_category = next(iter(ai_audit_analysis_categories))
+            initial_sub_categories = ai_audit_analysis_categories[initial_main_category]
+
+            main_category_radio = gr.Radio(list(ai_audit_analysis_categories.keys()), label="Main Audit Categories", value=initial_main_category)
+            sub_category_dropdown = gr.Dropdown(choices=initial_sub_categories, label="Sub Categories", value=initial_sub_categories[0])
+            # Update the dropdown based on the radio selection
+            main_category_radio.change(fn=update_dropdown, inputs= main_category_radio, outputs=sub_category_dropdown)
+            sub_category_dropdown.change(fn=update_analysis_type, inputs=sub_category_dropdown)
+
+            load_last_message_btn = gr.Button("Load Last Message")
+            load_complete_conv_btn = gr.Button("Load Complete Chat History")
+            process_btn = gr.Button("Process")
+            # analysis_result = gr.Label()
+            analysis_result = gr.Markdown()
+            load_last_message_btn.click(load_chatboat_last_message, inputs=[], outputs=text_field)
+            load_complete_conv_btn.click(load_chatboat_complet_history, inputs=[], outputs=text_field)
+            process_btn.click(analyse_current_conversation, inputs=[text_field, sub_category_dropdown], outputs=analysis_result)
+
+demo.launch(share=True)
+

requirements.txt

@@ -0,0 +1,3 @@
+requests
+gradio
+openai

utils.py

@@ -0,0 +1,136 @@
+
+
+ai_audit_analysis_categories = {
+    "AI Audit": [
+        "sentiment_analysis", 
+        "emotion_detection", 
+        "political_bias_detection", 
+        "stress_level_detection",
+        "empathy_level_assessment",
+        "mood_detection",
+        "toxicity_detection"
+        ],
+
+    "GDPR": [
+        "Data Handling and Processing", 
+        "Consent and Transparency", 
+        "Data Security", 
+        "Environmental Impact"],
+
+    "Toxicity": [
+        "Content Moderation", 
+        "Reporting Mechanism", 
+        "Content guidelines", 
+        "User Education"],
+
+    "Legal": [
+        "Privacy Policy", 
+        "Data Retention", 
+        "Consent Mechanism", 
+        "GDPR Compliance"],
+
+    "Context": [
+        "Ethical AI", 
+        "Bais Mitigation", 
+        "Fairness Assestment", 
+        "Explainability"],
+
+    "Governance": [
+        "Model development", 
+        "Data Quality", 
+        "Bais Mitigation", 
+        "Fairness Assestment"
+        "Explainability"
+        "User Input"],
+
+    "RiskManagement": [
+     "Corporate Ethics", 
+     "Board Management", 
+     "Stakeholder Engagement", 
+     "Risk Management"],
+    
+    "Robustness": [
+        "System Reliability", 
+        "Quality Assurance", "Stress Testing", 
+        "Fail-Safe Procedures"],
+
+    "Sustainability": [
+        "Renewable Resources", 
+        "Waste Reduction", 
+        "Energy Efficiency", 
+        "Sustainable Practices"]
+}
+
+
+
+
+
+
+# Define a standard template for prompts
+STANDARD_PROMPT_TEMPLATE = "You are a data analysis assistant capable of {analysis_type} analysis. {specific_instruction} Respond with your analysis in JSON format. The JSON schema should include '{json_schema}'."
+
+
+
+
+def get_system_prompt(analysis_type: str) -> str:
+    specific_instruction = ANALYSIS_TYPES.get(analysis_type, "Perform the analysis as per the specified type.")
+    json_schema = JSON_SCHEMAS.get(analysis_type, {})
+    json_schema_str = ', '.join([f"'{key}': {value}" for key, value in json_schema.items()])
+    return (f"You are a data analyst API capable of {analysis_type} analysis. "
+            f"{specific_instruction} Please respond with your analysis directly in JSON format "
+            f"(without using Markdown code blocks or any other formatting). Always include confidence_score:number (0-1) with two decimals for result based on analysis"
+            f"The JSON schema should include: {{{json_schema_str}}}.")
+
+
+
+
+ANALYSIS_TYPES = {
+    "sentiment_analysis": "Analyze the sentiment of the provided text. Determine whether the sentiment is positive, negative, or neutral and provide a confidence score.",
+    "emotion_detection": "Detect and identify the primary emotions expressed in the provided text. Provide a score for the intensity of the detected emotion.",
+    "political_bias_detection": "Detect any political bias in the provided text, identifying leaning towards particular ideologies or parties.",
+    "stress_level_detection": "Analyze the text to assess stress levels, identifying triggers and intensity of stress.",
+    "empathy_level_assessment": "Assess the level of empathy expressed in the text, identifying empathetic responses and tendencies.",
+    "mood_detection": "Detect the mood of the individual based on textual cues, ranging from happy to sad, calm to angry.",
+    "toxicity_detection": "Identify and assess the level of toxicity in the provided text. Determine whether the text contains harmful, offensive, or inappropriate content and provide a score indicating the severity of the toxicity"
+}
+
+
+JSON_SCHEMAS = {
+    "sentiment_analysis": {
+         "sentiment": "string (positive, negative, neutral)",
+         "confidence_score": "number (0-1)",
+         "text_snippets": "array of strings (specific text portions contributing to sentiment)"
+     },
+    "emotion_detection": {
+         "emotion": "string (primary emotion detected)",
+         "confidence_score": "number (0-1)",
+         "secondary_emotions": "array of objects (secondary emotions and their scores)"
+     },
+     "political_bias_detection": {
+         "bias": "string (left, right, neutral)",
+         "confidence_score": "number (0-1)",
+         "bias_indicators": "array of strings (elements indicating bias)",
+         "political_alignment_score": "number (quantifying degree of political bias)"
+     },
+     "stress_level_detection": {
+         "stress_level": "string", 
+         "stress_triggers": "array of strings"
+     },
+    "empathy_level_assessment": {
+         "empathy_level": "string", 
+         "empathetic_responses": "array of strings"
+     },
+     "mood_detection": {
+         "mood": "string", 
+         "mood_intensity": "number"
+     },
+     "toxicity_detection": {
+         "toxicity_level": "string (none, low, medium, high)",
+         "toxicity_flags": "array of strings (specific words or phrases contributing to toxicity)",
+         "contextual_factors": "array of objects (additional contextual elements influencing toxicity interpretation)"
+     }
+}
+
+
+
+