# Fix for torch.classes watchdog errors
import sys
class ModuleProtector:
def __init__(self, module_name):
self.module_name = module_name
self.original_module = sys.modules.get(module_name)
def __enter__(self):
if self.module_name in sys.modules:
self.original_module = sys.modules[self.module_name]
sys.modules[self.module_name] = None
def __exit__(self, *args):
if self.original_module is not None:
sys.modules[self.module_name] = self.original_module
# Temporarily remove torch.classes from sys.modules to prevent Streamlit's file watcher from accessing it
with ModuleProtector('torch.classes'):
import streamlit as st
# Set page configuration - MUST BE THE FIRST STREAMLIT COMMAND
st.set_page_config(
page_title="Multilingual Toxicity Analyzer",
page_icon="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0IiBmaWxsPSJub25lIiBzdHJva2U9ImN1cnJlbnRDb2xvciIgc3Ryb2tlLXdpZHRoPSIyIiBzdHJva2UtbGluZWNhcD0icm91bmQiIHN0cm9rZS1saW5lam9pbj0icm91bmQiIGNsYXNzPSJsdWNpZGUgbHVjaWRlLXNoaWVsZC1wbHVzLWljb24gbHVjaWRlLXNoaWVsZC1wbHVzIj48cGF0aCBkPSJNMjAgMTNjMCA1LTMuNSA3LjUtNy42NiA4Ljk1YTEgMSAwIDAgMS0uNjctLjAxQzcuNSAyMC41IDQgMTggNCAxM1Y2YTEgMSAwIDAgMSAxLTFjMiAwIDQuNS0xLjIgNi4yNC0yLjcyYTEuMTcgMS4xNyAwIDAgMSAxLjUyIDBDMTQuNTEgMy44MSAxNyA1IDE5IDVhMSAxIDAgMCAxIDEgMXoiLz48cGF0aCBkPSJNOSAxMmg2Ii8+PHBhdGggZD0iTTEyIDl2NiIvPjwvc3ZnPg==",
layout="wide",
initial_sidebar_state="expanded"
)
# Now import all other dependencies
import torch
import os
import plotly.graph_objects as go
import pandas as pd
from model.inference_optimized import OptimizedToxicityClassifier
import langid
from typing import List, Dict
import time
import psutil
import platform
try:
import cpuinfo
except ImportError:
cpuinfo = None
from streamlit_extras.colored_header import colored_header
from streamlit_extras.add_vertical_space import add_vertical_space
from streamlit_extras.stylable_container import stylable_container
from streamlit_extras.card import card
from streamlit_extras.metric_cards import style_metric_cards
# Configure paths
ONNX_MODEL_PATH = os.environ.get("ONNX_MODEL_PATH", "weights/toxic_classifier.onnx")
PYTORCH_MODEL_DIR = os.environ.get("PYTORCH_MODEL_DIR", "weights/toxic_classifier_xlm-roberta-large")
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
# Get GPU info if available
def get_gpu_info():
if DEVICE == "cuda":
try:
gpu_name = torch.cuda.get_device_name(0)
gpu_memory_total = torch.cuda.get_device_properties(0).total_memory / 1024**3 # Convert to GB
gpu_memory_allocated = torch.cuda.memory_allocated(0) / 1024**3 # Convert to GB
cuda_version = torch.version.cuda
memory_info = f"{gpu_memory_allocated:.1f}/{gpu_memory_total:.1f} GB"
return f"{gpu_name} (CUDA {cuda_version}, Memory: {memory_info})"
except Exception as e:
return "CUDA device"
return "CPU"
# Get CPU information
def get_cpu_info():
try:
cpu_percent = psutil.cpu_percent(interval=0.1)
cpu_count = psutil.cpu_count(logical=True)
cpu_freq = psutil.cpu_freq()
if cpu_freq:
freq_info = f"{cpu_freq.current/1000:.2f} GHz"
else:
freq_info = "Unknown"
# Try multiple methods to get CPU model name
cpu_model = None
# Method 1: Try reading from /proc/cpuinfo directly
try:
with open('/proc/cpuinfo', 'r') as f:
for line in f:
if 'model name' in line:
cpu_model = line.split(':', 1)[1].strip()
break
except:
pass
# Method 2: If Method 1 fails, try using platform.processor()
if not cpu_model:
cpu_model = platform.processor()
# Method 3: If still no result, try using platform.machine()
if not cpu_model or cpu_model == '':
cpu_model = platform.machine()
# Method 4: Final fallback to using psutil
if not cpu_model or cpu_model == '':
try:
import cpuinfo
cpu_model = cpuinfo.get_cpu_info()['brand_raw']
except:
pass
# Clean up the model name
if cpu_model:
# Remove common unnecessary parts
replacements = [
'(R)', '(TM)', '(r)', '(tm)', 'CPU', '@', ' ', 'Processor'
]
for r in replacements:
cpu_model = cpu_model.replace(r, ' ')
# Clean up extra spaces
cpu_model = ' '.join(cpu_model.split())
# Limit length
if len(cpu_model) > 40:
cpu_model = cpu_model[:37] + "..."
else:
cpu_model = "Unknown CPU"
return {
"name": cpu_model,
"cores": cpu_count,
"freq": freq_info,
"usage": f"{cpu_percent:.1f}%"
}
except Exception as e:
return {
"name": "CPU",
"cores": "Unknown",
"freq": "Unknown",
"usage": "Unknown"
}
# Get RAM information
def get_ram_info():
try:
ram = psutil.virtual_memory()
ram_total = ram.total / (1024**3) # Convert to GB
ram_used = ram.used / (1024**3) # Convert to GB
ram_percent = ram.percent
return {
"total": f"{ram_total:.1f} GB",
"used": f"{ram_used:.1f} GB",
"percent": f"{ram_percent:.1f}%"
}
except Exception as e:
return {
"total": "Unknown",
"used": "Unknown",
"percent": "Unknown"
}
# Update system resource information
def update_system_resources():
cpu_info = get_cpu_info()
ram_info = get_ram_info()
return {
"cpu": cpu_info,
"ram": ram_info
}
# Initialize system information
GPU_INFO = get_gpu_info()
SYSTEM_INFO = update_system_resources()
# Add a function to update GPU memory info in real-time
def update_gpu_info():
if DEVICE == "cuda":
try:
gpu_memory_allocated = torch.cuda.memory_allocated(0) / 1024**3 # Convert to GB
gpu_memory_total = torch.cuda.get_device_properties(0).total_memory / 1024**3 # Convert to GB
return f"{gpu_memory_allocated:.1f}/{gpu_memory_total:.1f} GB"
except:
return "N/A"
return "N/A"
# Helper function to convert hex to rgba
def hex_to_rgba(hex_color, alpha=1.0):
hex_color = hex_color.lstrip('#')
r = int(hex_color[0:2], 16)
g = int(hex_color[2:4], 16)
b = int(hex_color[4:6], 16)
return f'rgba({r}, {g}, {b}, {alpha})'
# Supported languages with emoji flags
SUPPORTED_LANGUAGES = {
'en': {'name': 'English', 'flag': '🇺🇸'},
'ru': {'name': 'Russian', 'flag': '🇷🇺'},
'tr': {'name': 'Turkish', 'flag': '🇹🇷'},
'es': {'name': 'Spanish', 'flag': '🇪🇸'},
'fr': {'name': 'French', 'flag': '🇫🇷'},
'it': {'name': 'Italian', 'flag': '🇮🇹'},
'pt': {'name': 'Portuguese', 'flag': '🇵🇹'}
}
# Language examples - expanded with multiple examples per language, categorized as toxic or non-toxic
LANGUAGE_EXAMPLES = {
'en': {
'toxic': [
"You are such an idiot, nobody likes your stupid content.",
"Shut up you worthless piece of garbage. Everyone hates you.",
"This is the most pathetic thing I've ever seen. Only losers would think this is good.",
"Just kill yourself already, the world would be better without you."
],
'non_toxic': [
"I disagree with your opinion, but I appreciate your perspective.",
"This content could use some improvement, but I see the effort you put into it.",
"While I don't personally enjoy this type of content, others might find it valuable.",
"Thank you for sharing your thoughts on this complex topic."
]
},
'ru': {
'toxic': [
"Ты полный придурок, твой контент никому не нравится.",
"Заткнись, бесполезный кусок мусора. Все тебя ненавидят.",
"Это самая жалкая вещь, которую я когда-либо видел. Только неудачники думают, что это хорошо.",
"Почему бы тебе просто не исчезнуть нахрен? Никто не будет скучать по тебе."
],
'non_toxic': [
"Я не согласен с вашим мнением, но уважаю вашу точку зрения.",
"Этот контент можно улучшить, но я вижу, сколько усилий вы в него вложили.",
"Хотя мне лично не нравится такой контент, другие могут найти его полезным.",
"Спасибо, что поделились своими мыслями на эту сложную тему."
]
},
'tr': {
'toxic': [
"Sen tam bir aptalsın, kimse senin aptalca içeriğini beğenmiyor.",
"Kapa çeneni değersiz çöp parçası. Herkes senden nefret ediyor.",
"Bu gördüğüm en acıklı şey. Sadece lanet olası kaybedenler bunun iyi olduğunu düşünür.",
"Dünya sensiz daha iyi olurdu, kaybol git."
],
'non_toxic': [
"Fikrinize katılmıyorum ama bakış açınızı takdir ediyorum.",
"Bu içerik biraz geliştirilebilir, ancak gösterdiğiniz çabayı görüyorum.",
"Şahsen bu tür içerikten hoşlanmasam da, başkaları bunu değerli bulabilir.",
"Bu karmaşık konu hakkındaki düşüncelerinizi paylaştığınız için teşekkür ederim."
]
},
'es': {
'toxic': [
"Eres un completo idiota y nadie te quiere.",
"Cállate, pedazo de basura inútil. Todos te odian.",
"Esto es lo más patético que he visto nunca. Solo los perdedores pensarían que esto es bueno.",
"El mundo estaría mejor sin ti, deberías desaparecer, joder."
],
'non_toxic': [
"No estoy de acuerdo con tu opinión, pero aprecio tu perspectiva.",
"Este contenido podría mejorarse, pero veo el esfuerzo que has puesto en él.",
"Aunque personalmente no disfruto este tipo de contenido, otros podrían encontrarlo valioso.",
"Gracias por compartir tus pensamientos sobre este tema tan complejo."
]
},
'fr': {
'toxic': [
"Tu es tellement stupide, personne n'aime ton contenu minable.",
"Ferme-la, espèce de déchet inutile. Tout le monde te déteste.",
"C'est la chose la plus pathétique que j'ai jamais vue. Seuls les loosers penseraient que c'est bien.",
"Le monde serait meilleur sans toi, connard, va-t'en."
],
'non_toxic': [
"Je ne suis pas d'accord avec ton opinion, mais j'apprécie ta perspective.",
"Ce contenu pourrait être amélioré, mais je vois l'effort que tu y as mis.",
"Bien que personnellement je n'apprécie pas ce type de contenu, d'autres pourraient le trouver précieux.",
"Merci d'avoir partagé tes réflexions sur ce sujet complexe."
]
},
'it': {
'toxic': [
"Sei un tale idiota, a nessuno piace il tuo contenuto stupido.",
"Chiudi quella bocca, pezzo di spazzatura inutile. Tutti ti odiano.",
"Questa è la cosa più patetica che abbia mai visto. Solo i perdenti penserebbero che sia buona.",
"Il mondo sarebbe migliore senza di te, sparisci."
],
'non_toxic': [
"Non sono d'accordo con la tua opinione, ma apprezzo la tua prospettiva.",
"Questo contenuto potrebbe essere migliorato, ma vedo lo sforzo che ci hai messo.",
"Anche se personalmente non apprezzo questo tipo di contenuto, altri potrebbero trovarlo utile.",
"Grazie per aver condiviso i tuoi pensieri su questo argomento complesso."
]
},
'pt': {
'toxic': [
"Você é um idiota completo, ninguém gosta do seu conteúdo estúpido.",
"Cale a boca, seu pedaço de lixo inútil. Todos te odeiam.",
"Isso é a coisa mais patética que eu já vi. Só perdedores pensariam que isso é bom.",
"O mundo seria melhor sem você, desapareça."
],
'non_toxic': [
"Eu discordo da sua opinião, mas aprecio sua perspectiva.",
"Este conteúdo poderia ser melhorado, mas vejo o esforço que você colocou nele.",
"Embora eu pessoalmente não goste deste tipo de conteúdo, outros podem achá-lo valioso.",
"Obrigado por compartilhar seus pensamentos sobre este tema complexo."
]
}
}
# Theme colors - Light theme with black text
THEME = {
"primary": "#2D3142",
"background": "#FFFFFF",
"surface": "#FFFFFF",
"text": "#000000", # Changed to pure black for maximum contrast
"text_secondary": "#FFFFFF", # For text that needs to be white
"button": "#000000", # Dark black for buttons
"toxic": "#E53935", # Darker red for better contrast
"non_toxic": "#2E7D32", # Darker green for better contrast
"warning": "#F57C00", # Darker orange for better contrast
"info": "#1976D2", # Darker blue for better contrast
"sidebar_bg": "#FFFFFF",
"card_bg": "white",
"input_bg": "#F8F9FA"
}
# Custom CSS for better styling
st.markdown(f"""
""", unsafe_allow_html=True)
# Custom CSS for metric labels - Add this near the top with the other CSS
st.markdown(f"""
""", unsafe_allow_html=True)
# Load model at app start
@st.cache_resource
def load_classifier():
try:
if os.path.exists(ONNX_MODEL_PATH):
classifier = OptimizedToxicityClassifier(onnx_path=ONNX_MODEL_PATH, device=DEVICE)
st.session_state['model_type'] = 'Loaded'
return classifier
elif os.path.exists(PYTORCH_MODEL_DIR):
classifier = OptimizedToxicityClassifier(pytorch_path=PYTORCH_MODEL_DIR, device=DEVICE)
st.session_state['model_type'] = 'Loaded'
return classifier
else:
st.error(f"❌ No model found at {ONNX_MODEL_PATH} or {PYTORCH_MODEL_DIR}")
return None
except Exception as e:
st.error(f"Error loading model: {str(e)}")
import traceback
st.error(traceback.format_exc())
return None
def detect_language(text: str) -> str:
"""Detect language of input text"""
try:
lang, _ = langid.classify(text)
return lang if lang in SUPPORTED_LANGUAGES else 'en'
except:
return 'en'
def predict_toxicity(text: str, selected_language: str = "Auto-detect") -> Dict:
"""Predict toxicity of input text"""
if not text or not text.strip():
return {
"error": "Please enter some text to analyze.",
"results": None
}
if not st.session_state.get('model_loaded', False):
return {
"error": "Model not loaded. Please check logs.",
"results": None
}
# Add a spinner while processing
with st.spinner("Analyzing text..."):
# Record start time for inference metrics
start_time = time.time()
# Detect language if auto-detect is selected
if selected_language == "Auto-detect":
lang_detection_start = time.time()
lang_code = detect_language(text)
lang_detection_time = time.time() - lang_detection_start
detected = True
else:
# Get language code from the display name without flag
selected_name = selected_language.split(' ')[1] if len(selected_language.split(' ')) > 1 else selected_language
lang_code = next((code for code, info in SUPPORTED_LANGUAGES.items()
if info['name'] == selected_name), 'en')
lang_detection_time = 0
detected = False
# Run prediction
try:
model_inference_start = time.time()
results = classifier.predict([text], langs=[lang_code])[0]
model_inference_time = time.time() - model_inference_start
total_time = time.time() - start_time
return {
"results": results,
"detected": detected,
"lang_code": lang_code,
"performance": {
"total_time": total_time,
"lang_detection_time": lang_detection_time,
"model_inference_time": model_inference_time
}
}
except Exception as e:
import traceback
traceback.print_exc()
return {
"error": f"Error processing text: {str(e)}",
"results": None
}
# Function to set example text
def set_example(lang_code, example_type, example_index=0):
st.session_state['use_example'] = True
# Get the example based on the language, type and index
example = LANGUAGE_EXAMPLES[lang_code][example_type][example_index]
st.session_state['example_text'] = example
st.session_state['detected_lang'] = lang_code
st.session_state['example_info'] = {
'type': example_type,
'lang': lang_code,
'index': example_index
}
# Initialize session state for example selection if not present
if 'use_example' not in st.session_state:
st.session_state['use_example'] = False
st.session_state['example_text'] = ""
st.session_state['detected_lang'] = "Auto-detect"
st.session_state['example_info'] = None
# Sidebar content
with st.sidebar:
st.markdown("
Multilingual Toxicity Analyzer
", unsafe_allow_html=True)
st.markdown("""
#### This app analyzes text for different types of toxicity across multiple languages with high accuracy.
""")
# Create language cards with flags
st.markdown("#### Supported Languages:")
lang_cols = st.columns(2)
for i, (code, info) in enumerate(SUPPORTED_LANGUAGES.items()):
col_idx = i % 2
with lang_cols[col_idx]:
st.markdown(f"
{info['flag']} {info['name']}
",
unsafe_allow_html=True)
st.divider()
# Language selection dropdown moved to sidebar
st.markdown("### 🌐 Select Language")
language_options = ["Auto-detect"] + [f"{info['flag']} {info['name']}" for code, info in SUPPORTED_LANGUAGES.items()]
selected_language = st.selectbox(
"Choose language or use auto-detect",
language_options,
index=0,
key="selected_language",
help="Choose a specific language or use auto-detection"
)
# Examples moved to sidebar
st.markdown("### 📝 Try with examples:")
# Create tabs for toxic and non-toxic examples
example_tabs = st.tabs(["Toxic Examples", "Non-Toxic Examples"])
# Order languages by putting the most common ones first
ordered_langs = ['en', 'es', 'fr', 'pt', 'it', 'ru', 'tr']
# Toxic examples tab
with example_tabs[0]:
st.markdown('
', unsafe_allow_html=True)
for lang_code in ordered_langs:
info = SUPPORTED_LANGUAGES[lang_code]
with st.expander(f"{info['flag']} {info['name']} examples"):
for i, example in enumerate(LANGUAGE_EXAMPLES[lang_code]['toxic']):
# Display a preview of the example
preview = example[:40] + "..." if len(example) > 40 else example
button_key = f"toxic_{lang_code}_{i}"
button_help = f"Try with this {info['name']} toxic example"
# We can't directly apply CSS classes to Streamlit buttons, but we can wrap them
if st.button(f"Example {i+1}: {preview}",
key=button_key,
use_container_width=True,
help=button_help):
set_example(lang_code, 'toxic', i)
st.markdown('
', unsafe_allow_html=True)
# Non-toxic examples tab
with example_tabs[1]:
st.markdown('
', unsafe_allow_html=True)
for lang_code in ordered_langs:
info = SUPPORTED_LANGUAGES[lang_code]
with st.expander(f"{info['flag']} {info['name']} examples"):
for i, example in enumerate(LANGUAGE_EXAMPLES[lang_code]['non_toxic']):
# Display a preview of the example
preview = example[:40] + "..." if len(example) > 40 else example
button_key = f"non_toxic_{lang_code}_{i}"
button_help = f"Try with this {info['name']} non-toxic example"
if st.button(f"Example {i+1}: {preview}",
key=button_key,
use_container_width=True,
help=button_help):
set_example(lang_code, 'non_toxic', i)
st.markdown('
', unsafe_allow_html=True)
st.divider()
# Model and Hardware information in the sidebar with improved layout
st.markdown("### 💻 System Information", unsafe_allow_html=True)
# Update system resources info
current_sys_info = update_system_resources()
# GPU section
if DEVICE == "cuda":
st.markdown("""
", unsafe_allow_html=True)
st.divider()
# Toxicity Thresholds - Moved from results section to sidebar
st.markdown("### ⚙️ Toxicity Thresholds")
st.markdown("""
The model uses language-specific thresholds to determine if a text is toxic:
- **Toxic**: 60%
- **Severe Toxic**: 54%
- **Obscene**: 60%
- **Threat**: 48%
- **Insult**: 60%
- **Identity Hate**: 50%
These increased thresholds reduce false positives but may miss borderline toxic content.
""", unsafe_allow_html=True)
# Display model loading status
if 'model_loaded' not in st.session_state:
with st.spinner("🔄 Loading model..."):
classifier = load_classifier()
if classifier:
st.session_state['model_loaded'] = True
st.success(f"✅ Model loaded successfully on {GPU_INFO}")
else:
st.session_state['model_loaded'] = False
st.error("❌ Failed to load model. Please check logs.")
else:
# Model already loaded, just get it from cache
classifier = load_classifier()
# Main app
st.markdown("""
Multilingual Toxicity Analyzer
""", unsafe_allow_html=True)
st.markdown("""
Detect toxic content in multiple languages with state-of-the-art accuracy
""", unsafe_allow_html=True)
# Text input area with interactive styling
with stylable_container(
key="text_input_container",
css_styles=f"""
{{
border-radius: 10px;
overflow: hidden;
transition: all 0.3s ease;
box-shadow: 0 2px 8px rgba(0,0,0,0.15);
background-color: {THEME["card_bg"]};
padding: 10px;
margin-bottom: 15px;
}}
textarea {{
caret-color: black !important;
color: {THEME["text"]} !important;
}}
/* Ensure the text input cursor is visible */
.stTextArea textarea {{
caret-color: black !important;
}}
"""
):
# Get the current example text if it exists
current_example = st.session_state.get('example_text', '')
# Set the text input value, allowing for modifications
text_input = st.text_area(
"Enter text to analyze",
height=80,
value=current_example if st.session_state.get('use_example', False) else st.session_state.get('text_input', ''),
key="text_input",
help="Enter text in any supported language to analyze for toxicity"
)
# Check if the text has been modified from the example
if st.session_state.get('use_example', False) and text_input != current_example:
# Text was modified, clear example state
st.session_state['use_example'] = False
st.session_state['example_text'] = ""
st.session_state['example_info'] = None
# Analyze button with improved styling in a more compact layout
col1, col2, col3 = st.columns([1, 2, 1])
with col2:
analyze_button = st.button(
"Analyze Text",
type="primary",
use_container_width=True,
help="Click to analyze the entered text for toxicity"
)
# Process when button is clicked or text is submitted
if analyze_button or (text_input and 'last_analyzed' not in st.session_state or st.session_state.get('last_analyzed') != text_input):
if text_input:
st.session_state['last_analyzed'] = text_input
# Get system resource info before prediction
pre_prediction_resources = update_system_resources()
# Make prediction
prediction = predict_toxicity(text_input, selected_language)
# Update resource usage after prediction
post_prediction_resources = update_system_resources()
# Calculate resource usage delta
resource_delta = {
"cpu_usage": float(post_prediction_resources["cpu"]["usage"].rstrip("%")) - float(pre_prediction_resources["cpu"]["usage"].rstrip("%")),
"ram_usage": float(post_prediction_resources["ram"]["percent"].rstrip("%")) - float(pre_prediction_resources["ram"]["percent"].rstrip("%"))
}
# Update GPU memory info after prediction
if DEVICE == "cuda":
new_memory_info = update_gpu_info()
# Note: Ideally we would update the displayed memory usage here,
# but Streamlit doesn't support dynamic updates without a rerun,
# so we'll just include memory info in our metrics
# Set analysis status flags but remove celebration effect code
st.session_state['is_analysis_complete'] = True
st.session_state['analysis_has_error'] = "error" in prediction and prediction["error"]
if "error" in prediction and prediction["error"]:
st.error(prediction["error"])
elif prediction["results"]:
# Remove celebration effect call
# celebration_effect()
results = prediction["results"]
performance = prediction.get("performance", {})
# Overall toxicity result
is_toxic = results["is_toxic"]
result_color = THEME["toxic"] if is_toxic else THEME["non_toxic"]
result_text = "TOXIC" if is_toxic else "NON-TOXIC"
# Language info
lang_code = prediction["lang_code"]
lang_info = SUPPORTED_LANGUAGES.get(lang_code, {"name": lang_code, "flag": "🌐"})
# Count toxic categories
toxic_count = len(results["toxic_categories"]) if is_toxic else 0
# Create data for visualization but don't display the table
categories = []
probabilities = []
statuses = []
# Use the same thresholds that are used in the inference model
category_thresholds = {
'toxic': 0.60,
'severe_toxic': 0.54,
'obscene': 0.60,
'threat': 0.48,
'insult': 0.60,
'identity_hate': 0.50
}
for label, prob in results["probabilities"].items():
categories.append(label.replace('_', ' ').title())
probabilities.append(round(prob * 100, 1))
threshold = category_thresholds.get(label, 0.5) * 100
statuses.append("DETECTED" if prob * 100 >= threshold else "Not Detected")
# Sort by probability for the chart
chart_data = sorted(zip(categories, probabilities, statuses), key=lambda x: x[1], reverse=True)
chart_cats, chart_probs, chart_statuses = zip(*chart_data)
# Two column layout for results
col1, col2 = st.columns([3, 2])
with col1:
# Card with overall result and detected categories
with stylable_container(
key="result_card",
css_styles=f"""
{{
border-radius: 10px;
padding: 10px 15px;
background-color: {THEME["card_bg"]};
border-left: 5px solid {result_color};
margin-bottom: 10px;
box-shadow: 0 4px 12px rgba(0,0,0,0.1);
overflow: hidden;
}}
"""
):
# Overall result with abbreviated display
st.markdown(f"""
Analysis Result:
{result_text}
Language: {lang_info['flag']} {lang_info['name']} {'(detected)' if prediction["detected"] else ''}
Toxic Categories: {", ".join([f'{category.replace("_", " ").title()}' for category in results["toxic_categories"]]) if is_toxic and toxic_count > 0 else 'None'}
""", unsafe_allow_html=True)
# Add toxicity probability graph inside the result card
st.markdown("
Toxicity Probabilities:
", unsafe_allow_html=True)
# Create a horizontal bar chart with Plotly
fig = go.Figure()
# Add bars with different colors based on toxicity
for i, (cat, prob, status) in enumerate(zip(chart_cats, chart_probs, chart_statuses)):
color = THEME["toxic"] if status == "DETECTED" else THEME["non_toxic"]
border_color = hex_to_rgba(color, 0.85) # Using rgba for border
fig.add_trace(go.Bar(
y=[cat],
x=[prob],
orientation='h',
name=cat,
marker=dict(
color=color,
line=dict(
color=border_color,
width=2
)
),
text=[f"{prob}%"],
textposition='outside',
textfont=dict(size=16, weight='bold'), # Much larger, bold text
hoverinfo='text',
hovertext=[f"{cat}: {prob}%"]
))
# Update layout
fig.update_layout(
title=None,
xaxis_title="Probability (%)",
yaxis_title=None, # Remove y-axis title to save space
height=340, # Significantly increased height
margin=dict(l=10, r=40, t=20, b=40), # More margin space for labels
xaxis=dict(
range=[0, 115], # Extended for outside labels
gridcolor=hex_to_rgba(THEME["text"], 0.15),
zerolinecolor=hex_to_rgba(THEME["text"], 0.3),
color=THEME["text"],
tickfont=dict(size=15), # Larger tick font
title_font=dict(size=16, family="Space Grotesk, sans-serif") # Larger axis title
),
yaxis=dict(
gridcolor=hex_to_rgba(THEME["text"], 0.15),
color=THEME["text"],
tickfont=dict(size=15, family="Space Grotesk, sans-serif", weight='bold'), # Larger, bold category names
automargin=True # Auto-adjust margin to fit category names
),
bargap=0.3, # More space between bars
paper_bgcolor='rgba(0,0,0,0)',
plot_bgcolor='rgba(0,0,0,0)',
font=dict(
family="Space Grotesk, sans-serif",
color=THEME["text"],
size=15 # Larger base font size
),
showlegend=False
)
# Grid lines
fig.update_xaxes(
showgrid=True,
gridwidth=1.5, # Slightly wider grid lines
gridcolor=hex_to_rgba(THEME["text"], 0.15),
dtick=20
)
# Display the plot
st.plotly_chart(fig, use_container_width=True, config={
'displayModeBar': False,
'displaylogo': False
})
with col2:
# Performance metrics card
if performance:
with stylable_container(
key="performance_metrics_card",
css_styles=f"""
{{
border-radius: 10px;
padding: 20px;
background-color: {THEME["card_bg"]};
border-left: 3px solid {THEME["primary"]};
height: 100%;
box-shadow: 0 4px 12px rgba(0,0,0,0.1);
}}
"""
):
st.markdown("
Performance Metrics
", unsafe_allow_html=True)
total_time = performance.get("total_time", 0)
inference_time = performance.get("model_inference_time", 0)
lang_detection_time = performance.get("lang_detection_time", 0)
# Create tabs for different types of metrics
perf_tab1, perf_tab2 = st.tabs(["Time Metrics", "Resource Usage"])
with perf_tab1:
time_cols = st.columns(1)
with time_cols[0]:
# Use custom HTML metrics instead of st.metric
total_time_val = f"{total_time:.3f}s"
inference_time_val = f"{inference_time:.3f}s"
lang_detection_time_val = f"{lang_detection_time:.3f}s"
st.markdown(f"""
Total Time
{total_time_val}
Model Inference
{inference_time_val}
Language Detection
{lang_detection_time_val}
""", unsafe_allow_html=True)
with perf_tab2:
# Display system resource metrics with custom HTML
current_sys_info = update_system_resources()
# Format delta: add + sign for positive values
cpu_usage = current_sys_info["cpu"]["usage"]
cpu_delta = f"{resource_delta['cpu_usage']:+.1f}%" if abs(resource_delta['cpu_usage']) > 0.1 else None
cpu_delta_display = f" ({cpu_delta})" if cpu_delta else ""
ram_usage = current_sys_info["ram"]["percent"]
ram_delta = f"{resource_delta['ram_usage']:+.1f}%" if abs(resource_delta['ram_usage']) > 0.1 else None
ram_delta_display = f" ({ram_delta})" if ram_delta else ""
if DEVICE == "cuda":
gpu_memory = update_gpu_info()
memory_display = f"GPU Memory: {gpu_memory}"
else:
memory_display = f"System RAM: {current_sys_info['ram']['used']} / {current_sys_info['ram']['total']}"
st.markdown(f"""
CPU Usage
{cpu_usage}{cpu_delta_display}
RAM Usage
{ram_usage}{ram_delta_display}
Memory
{memory_display}
""", unsafe_allow_html=True)
else:
pass # Remove the info message
# Bottom section with improved styling for usage guide
st.divider()
colored_header(
label="How to use this AI Model",
description="Follow these steps to analyze text for toxicity",
color_name="blue-70"
)
# Steps with more engaging design
st.markdown("""
1
Enter text in the input box above. You can type directly or paste from another source.
2
Select a specific language from the sidebar or use the auto-detect feature if you're unsure.
3
Click "Analyze Text" to get detailed toxicity analysis results.
4
Examine the breakdown of toxicity categories, probabilities, and visualization.
5
Try different examples from the sidebar to see how the model performs with various languages.
""", unsafe_allow_html=True)
# Adding footer with credits and improved styling
st.markdown("""
""", unsafe_allow_html=True)