Prediction: {pred_label}
Confidence: {confidence:.2%}
{get_label_description(pred_label)}
""", unsafe_allow_html=True)
st.plotly_chart(plot_probabilities(result['probabilities']), use_container_width=True)
with st.expander("🔍 Preprocessing Details", expanded=False):
col1, col2, col3 = st.columns(3)
with col1:
st.markdown("**Original Text:**")
st.code(text_input, language=None)
with col2:
st.markdown("**Preprocessed:**")
st.code(result['preprocessed_text'], language=None)
with col3:
if CUSTOM_MODULES_AVAILABLE and preprocessor:
script_info = get_script_info(text_input)
st.markdown("**Script Detected:**")
st.write(f"• Type: {script_info['script_type']}")
confidence_pct = min(script_info['confidence'] * 100, 100.0)
st.write(f"• Confidence: {confidence_pct:.1f}%")
if result.get('emoji_features', {}).get('total_emoji_count', 0) > 0:
with st.expander("😊 Emoji Analysis", expanded=False):
features = result['emoji_features']
col1, col2, col3 = st.columns(3)
with col1:
st.metric("Total Emojis", features['total_emoji_count'])
st.metric("Hate Emojis", features['hate_emoji_count'])
with col2:
st.metric("Positive Emojis", features['positive_emoji_count'])
st.metric("Mockery Emojis", features['mockery_emoji_count'])
with col3:
st.metric("Sadness Emojis", features['sadness_emoji_count'])
st.metric("Fear Emojis", features['fear_emoji_count'])
if CUSTOM_MODULES_AVAILABLE:
emoji_info = get_emoji_info(text_input)
if emoji_info['emojis_found']:
st.markdown("**Emojis Found:**")
st.write(" ".join(emoji_info['emojis_found']))
with st.expander("📊 Detailed Probabilities", expanded=False):
prob_df = pd.DataFrame({
'Class': list(result['probabilities'].keys()),
'Probability': list(result['probabilities'].values())
})
prob_df['Probability'] = prob_df['Probability'].apply(lambda x: f"{x:.4f}")
st.dataframe(prob_df, hide_index=True, use_container_width=True)
# ========================================================================
# TAB 2: EXPLAINABILITY
# ========================================================================
with tabs[1]:
st.subheader("💡 Model Explainability")
if not CUSTOM_MODULES_AVAILABLE:
st.error("❌ Explainability modules not available. Please check scripts directory.")
st.stop()
st.info(f"""
**Available Methods:**
- LIME: {'✅' if explainability_available['lime'] else '❌ (install: pip install lime)'}
- SHAP: {'✅' if explainability_available['shap'] else '❌ (install: pip install shap)'}
- Captum: {'✅' if captum_available else '❌ (install: pip install captum)'}
""")
explain_text = st.text_area(
"Enter text to explain",
height=150,
value=st.session_state.last_text if st.session_state.last_text else "",
placeholder="Enter Nepali text..."
)
available_methods = []
if explainability_available['lime']:
available_methods.append("LIME")
if explainability_available['shap']:
available_methods.append("SHAP")
if captum_available:
available_methods.append("Captum (IG)")
if not available_methods:
st.warning("⚠️ No explainability methods available. Please install required packages.")
st.code("pip install lime shap captum", language="bash")
st.stop()
method = st.selectbox("Select explanation method", available_methods)
with st.expander("⚙️ Configuration", expanded=False):
if method == "LIME":
num_samples = st.slider("Number of samples", 100, 500, 200, 50)
elif method == "SHAP":
use_fallback = st.checkbox("Use fallback if SHAP fails", value=True)
elif method == "Captum (IG)":
n_steps = st.slider("Integration steps", 10, 100, 50, 10)
explain_button = st.button("🔍 Generate Explanation", type="primary", use_container_width=True)
if explain_button and explain_text.strip():
with st.spinner("Generating explanation..."):
if st.session_state.model_wrapper is None:
st.session_state.model_wrapper = create_explainer_wrapper(
model, tokenizer, label_encoder, preprocessor
)
wrapper = st.session_state.model_wrapper
preprocessed, emoji_features = preprocessor.preprocess(explain_text)
analysis = wrapper.predict_with_analysis(explain_text)
st.success(f"**Prediction:** {analysis['predicted_label']} ({analysis['confidence']:.2%})")
col1, col2 = st.columns(2)
with col1:
st.write("**Original:**", explain_text)
with col2:
st.write("**Preprocessed:**", preprocessed)
st.markdown("---")
try:
if method == "LIME":
lime_exp = LIMEExplainer(wrapper, nepali_font=nepali_font)
result = lime_exp.explain_and_visualize(
analysis['original_text'],
analysis['preprocessed_text'],
save_path=None,
show=False,
num_samples=num_samples
)
st.subheader("LIME Explanation")
st.pyplot(result['figure'])
with st.expander("📊 Feature Importance Details"):
word_scores = result['explanation']['word_scores']
df = pd.DataFrame(word_scores, columns=['Word', 'Score'])
df = df.sort_values('Score', ascending=False)
st.dataframe(df, hide_index=True, use_container_width=True)
elif method == "SHAP":
shap_exp = SHAPExplainer(wrapper, nepali_font=nepali_font)
result = shap_exp.explain_and_visualize(
analysis['original_text'],
analysis['preprocessed_text'],
save_path=None,
show=False,
use_fallback=use_fallback
)
st.subheader("SHAP Explanation")
st.pyplot(result['figure'])
with st.expander("📊 Attribution Details"):
st.write(f"**Method used:** {result['explanation']['method_used']}")
word_scores = result['explanation']['word_scores']
df = pd.DataFrame(word_scores, columns=['Word', 'Score'])
df = df.sort_values('Score', key=lambda x: abs(x), ascending=False)
st.dataframe(df, hide_index=True, use_container_width=True)
elif method == "Captum (IG)":
try:
captum_exp = CaptumExplainer(
model, tokenizer, label_encoder, preprocessor,
emoji_to_nepali_map=EMOJI_TO_NEPALI
)
result = captum_exp.explain_and_visualize(
analysis['original_text'],
target=None,
n_steps=n_steps,
save_dir=None,
show=False,
nepali_font=nepali_font
)
st.subheader("Captum Integrated Gradients")
col1, col2 = st.columns(2)
with col1:
st.markdown("**Bar Chart**")
st.pyplot(result['bar_chart'])
with col2:
st.markdown("**Heatmap**")
st.pyplot(result['heatmap'])
with st.expander("📊 Attribution Details"):
st.write(f"**Convergence Delta:** {result['explanation']['convergence_delta']:.6f}")
word_attrs = result['explanation']['word_attributions']
df = pd.DataFrame(word_attrs, columns=['Word', 'Abs Score', 'Signed Score'])
df = df.sort_values('Abs Score', ascending=False)
st.dataframe(df, hide_index=True, use_container_width=True)
except (MemoryError, RuntimeError) as mem_err:
st.error("❌ Captum (Integrated Gradients) requires more memory than available on this server.")
st.info("💡 **Tip:** Use LIME or SHAP instead — they work great on cloud deployments. Captum works on local machines with more RAM/GPU.")
except Exception as e:
st.error(f"❌ Explanation failed: {str(e)}")
with st.expander("🐛 Error Details"):
st.exception(e)
# ========================================================================
# TAB 3: BATCH ANALYSIS
# ========================================================================
with tabs[2]:
st.subheader("📝 Batch Analysis")
st.markdown("### 📥 Download Example Files")
col1, col2 = st.columns(2)
with col1:
example_csv_data = {
'text': [
'यो राम्रो छ',
'तिमी मुर्ख हौ',
'मुस्लिम हरु सबै खराब छन्',
'केटीहरु घरमा बस्नु पर्छ',
'नमस्ते, कस्तो छ?'
]
}
example_csv = pd.DataFrame(example_csv_data).to_csv(index=False)
st.download_button(
label="📄 Download Example CSV",
data=example_csv,
file_name="example_batch.csv",
mime="text/csv",
use_container_width=True
)
with col2:
example_text = "यो राम्रो छ\nतिमी मुर्ख हौ\nमुस्लिम हरु सबै खराब छन्\nकेटीहरु घरमा बस्नु पर्छ\nनमस्ते, कस्तो छ?"
st.download_button(
label="📝 Download Example Text",
data=example_text,
file_name="example_batch.txt",
mime="text/plain",
use_container_width=True
)
st.markdown("---")
input_method = st.radio("Input method:", ["Text Area", "CSV Upload"])
# ---- TEXT AREA ----
if input_method == "Text Area":
st.info("💡 Enter one text per line")
batch_text = st.text_area(
"Enter texts (one per line)",
height=250,
placeholder="यो राम्रो छ\nतिमी मुर्ख हौ\n..."
)
if st.button("🚀 Analyze Batch", type="primary"):
if batch_text.strip():
texts = [line.strip() for line in batch_text.split('\n') if line.strip()]
with st.spinner(f"Analyzing {len(texts)} texts..."):
results = []
progress_bar = st.progress(0)
for idx, text in enumerate(texts):
try:
result = predict_text(
text, model, tokenizer,
label_encoder, preprocessor
)
results.append({
'Text': text[:60] + '...' if len(text) > 60 else text,
'Full_Text': text,
'Prediction': result['prediction'],
'Confidence': result['confidence'],
'Preprocessed': result['preprocessed_text']
})
except Exception as e:
results.append({
'Text': text[:60],
'Full_Text': text,
'Prediction': 'Error',
'Confidence': 0.0,
'Preprocessed': str(e)
})
progress_bar.progress((idx + 1) / len(texts))
st.session_state.batch_results = pd.DataFrame(results)
st.session_state.batch_mode = 'text_area'
for result in results:
if result['Prediction'] != 'Error':
st.session_state.session_predictions += 1
pred_label = result['Prediction']
if pred_label in st.session_state.session_class_counts:
st.session_state.session_class_counts[pred_label] += 1
st.rerun()
else:
st.warning("Please enter some texts.")
# Display results outside button block
if (st.session_state.batch_results is not None and
st.session_state.get('batch_mode') == 'text_area'):
results_df = st.session_state.batch_results
st.success(f"✅ Analyzed {len(results_df)} texts!")
display_df = results_df[['Text', 'Prediction', 'Confidence']].copy()
display_df['Confidence'] = display_df['Confidence'].apply(lambda x: f"{x:.2%}")
st.dataframe(display_df, use_container_width=True, hide_index=True, height=400)
st.markdown("---")
st.subheader("📊 Summary Statistics")
col1, col2, col3 = st.columns(3)
with col1:
st.metric("Total Texts", len(results_df))
st.metric("Avg Confidence", f"{results_df['Confidence'].mean():.2%}")
with col2:
summary = results_df['Prediction'].value_counts()
fig = px.pie(
values=summary.values,
names=summary.index,
title="Prediction Distribution",
color_discrete_sequence=px.colors.qualitative.Set2
)
st.plotly_chart(fig, use_container_width=True)
with col3:
st.markdown("**Class Breakdown:**")
for label, count in summary.items():
pct = count / len(results_df) * 100
st.write(f"• {label}: {count} ({pct:.1f}%)")
st.markdown("---")
download_df = results_df[['Full_Text', 'Prediction', 'Confidence', 'Preprocessed']].copy()
download_df.columns = ['Text', 'Prediction', 'Confidence', 'Preprocessed']
csv = download_df.to_csv(index=False)
col_download, col_explain = st.columns(2)
with col_download:
st.download_button(
label="📥 Download Results CSV",
data=csv,
file_name=f"batch_results_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
mime="text/csv",
use_container_width=True,
key="download_batch_text"
)
with col_explain:
if st.button("💡 Explain Selected", use_container_width=True, key="hint_batch_text"):
st.info("👇 Select a text below to explain")
render_batch_explainability(
results_df=results_df,
text_column='Full_Text',
model=model,
tokenizer=tokenizer,
label_encoder=label_encoder,
preprocessor=preprocessor,
nepali_font=nepali_font,
explainability_available=explainability_available,
captum_available=captum_available,
mode_key="text_area"
)
# ---- CSV UPLOAD ----
else:
st.info("💡 Upload CSV with a 'text' column")
uploaded_file = st.file_uploader(
"Choose CSV file",
type=['csv'],
help="Max 200MB. Upload a CSV with a text column containing Nepali text."
)
if uploaded_file:
try:
# Try multiple encodings for Nepali text compatibility
try:
df = pd.read_csv(uploaded_file, encoding='utf-8')
except UnicodeDecodeError:
uploaded_file.seek(0)
df = pd.read_csv(uploaded_file, encoding='latin-1')
st.write("📄 **File Preview:**")
st.dataframe(df.head(10), use_container_width=True)
text_column = st.selectbox("Select text column:", df.columns)
if st.button("🚀 Analyze CSV", type="primary"):
texts = df[text_column].astype(str).tolist()
with st.spinner(f"Analyzing {len(texts)} texts..."):
predictions = []
confidences = []
preprocessed_list = []
progress_bar = st.progress(0)
for idx, text in enumerate(texts):
try:
result = predict_text(
str(text), model, tokenizer,
label_encoder, preprocessor
)
predictions.append(result['prediction'])
confidences.append(result['confidence'])
preprocessed_list.append(result['preprocessed_text'])
except Exception as e:
predictions.append('Error')
confidences.append(0.0)
preprocessed_list.append(str(e))
progress_bar.progress((idx + 1) / len(texts))
df['Prediction'] = predictions
df['Confidence'] = confidences
df['Preprocessed'] = preprocessed_list
st.session_state.batch_results = df
st.session_state.batch_mode = 'csv'
st.session_state.csv_text_column = text_column
for pred in predictions:
if pred != 'Error':
st.session_state.session_predictions += 1
if pred in st.session_state.session_class_counts:
st.session_state.session_class_counts[pred] += 1
st.rerun()
# Display results outside button block
if (st.session_state.batch_results is not None and
st.session_state.get('batch_mode') == 'csv'):
df_results = st.session_state.batch_results
text_col = st.session_state.get('csv_text_column', text_column)
st.success("✅ Analysis complete!")
st.dataframe(df_results, use_container_width=True, height=400)
st.markdown("---")
st.subheader("📊 Summary")
col1, col2 = st.columns(2)
with col1:
summary = df_results['Prediction'].value_counts()
fig = px.bar(
x=summary.index,
y=summary.values,
title="Prediction Distribution",
labels={'x': 'Class', 'y': 'Count'},
color=summary.index,
color_discrete_map={
'NO': '#28a745',
'OO': '#ffc107',
'OR': '#dc3545',
'OS': '#6f42c1'
}
)
st.plotly_chart(fig, use_container_width=True)
with col2:
st.metric("Total Texts", len(df_results))
st.metric("Avg Confidence", f"{df_results['Confidence'].mean():.2%}")
st.markdown("**Class Distribution:**")
for label, count in summary.items():
st.write(f"• {label}: {count}")
st.markdown("---")
csv_data = df_results.to_csv(index=False)
col_download, col_explain = st.columns(2)
with col_download:
st.download_button(
label="📥 Download Results CSV",
data=csv_data,
file_name=f"predictions_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv",
mime="text/csv",
use_container_width=True,
key="download_csv_results"
)
with col_explain:
if st.button("💡 Explain Selected", use_container_width=True, key="csv_explain_hint"):
st.info("👇 Use expander below to explain")
render_batch_explainability(
results_df=df_results,
text_column=text_col,
model=model,
tokenizer=tokenizer,
label_encoder=label_encoder,
preprocessor=preprocessor,
nepali_font=nepali_font,
explainability_available=explainability_available,
captum_available=captum_available,
mode_key="csv"
)
except Exception as e:
st.error(f"❌ Error processing file: {str(e)}")
with st.expander("🐛 Error Details"):
st.exception(e)
# ========================================================================
# TAB 4: HISTORY
# ========================================================================
with tabs[3]:
st.subheader("📈 Prediction History")
col1, col2 = st.columns([3, 1])
with col1:
st.write("View and analyze your prediction history")
with col2:
if st.button("🔄 Refresh", use_container_width=True):
st.rerun()
if os.path.exists(HISTORY_FILE):
try:
with open(HISTORY_FILE, 'r', encoding='utf-8') as f:
history = json.load(f)
if history:
history_df = pd.DataFrame(history)
history_df['timestamp'] = pd.to_datetime(history_df['timestamp'])
st.markdown("### 📊 Overview")
col1, col2, col3, col4 = st.columns(4)
with col1:
st.metric("Total Predictions", len(history_df))
with col2:
st.metric("Avg Confidence", f"{history_df['confidence'].mean():.2%}")
with col3:
if 'emoji_features' in history_df.columns:
total_emojis = sum(
e.get('total_emoji_count', 0)
for e in history_df['emoji_features']
if isinstance(e, dict)
)
st.metric("Total Emojis", total_emojis)
else:
st.metric("Total Emojis", "N/A")
with col4:
most_common = history_df['prediction'].mode()[0]
st.metric("Most Common", most_common)
st.markdown("---")
st.markdown("### 📈 Trends")
col1, col2 = st.columns(2)
with col1:
daily_counts = history_df.groupby(
history_df['timestamp'].dt.date
).size().reset_index(name='count')
fig = px.line(
daily_counts,
x='timestamp',
y='count',
title="Predictions Over Time",
labels={'timestamp': 'Date', 'count': 'Count'}
)
st.plotly_chart(fig, use_container_width=True)
with col2:
class_dist = history_df['prediction'].value_counts()
fig = px.pie(
values=class_dist.values,
names=class_dist.index,
title="Class Distribution",
color=class_dist.index,
color_discrete_map={
'NO': '#28a745',
'OO': '#ffc107',
'OR': '#dc3545',
'OS': '#6f42c1'
}
)
st.plotly_chart(fig, use_container_width=True)
st.markdown("---")
st.markdown("### 📋 Recent Predictions")
num_to_show = st.slider("Number to show", 5, 50, 20, 5)
recent = history_df.tail(num_to_show).sort_values('timestamp', ascending=False)
display = recent[['timestamp', 'text', 'prediction', 'confidence']].copy()
display['confidence'] = display['confidence'].apply(lambda x: f"{x:.2%}")
display['text'] = display['text'].apply(lambda x: x[:80] + '...' if len(x) > 80 else x)
display['timestamp'] = display['timestamp'].dt.strftime('%Y-%m-%d %H:%M:%S')
st.dataframe(display, use_container_width=True, hide_index=True, height=400)
st.markdown("---")
col1, col2 = st.columns(2)
with col1:
csv = history_df.to_csv(index=False)
st.download_button(
label="📥 Download Full History",
data=csv,
file_name=f"history_{datetime.now().strftime('%Y%m%d')}.csv",
mime="text/csv",
use_container_width=True
)
with col2:
if st.button("🗑️ Clear History", type="secondary", use_container_width=True):
if os.path.exists(HISTORY_FILE):
os.remove(HISTORY_FILE)
st.success("✅ History cleared!")
st.rerun()
else:
st.info("📝 No predictions in history yet.")
except Exception as e:
st.error(f"❌ Error loading history: {str(e)}")
with st.expander("🐛 Error Details"):
st.exception(e)
else:
st.info("📝 No history file found yet.")
st.markdown("""
### How to Build History:
1. Go to **Single Prediction** tab
2. Enable "Save to history" checkbox
3. Analyze some text
4. Your predictions will appear here!
""")
if __name__ == "__main__":
main()