Spaces:
Sleeping
Sleeping
| import gradio as gr | |
| import pandas as pd | |
| import numpy as np | |
| from datetime import datetime | |
| import warnings | |
| warnings.filterwarnings('ignore') | |
| def smart_dataset_analysis(file): | |
| """Complete dataset analysis with intelligent recommendations""" | |
| if not file: return "Upload a dataset to get intelligent analysis." | |
| try: | |
| # Smart file reading | |
| df = pd.read_csv(file.name) if file.name.endswith('.csv') else pd.read_excel(file.name) | |
| # Deep dataset profiling | |
| profile = { | |
| 'shape': df.shape, | |
| 'numeric_cols': list(df.select_dtypes(include=[np.number]).columns), | |
| 'categorical_cols': list(df.select_dtypes(include=['object', 'category']).columns), | |
| 'datetime_cols': list(df.select_dtypes(include=['datetime64']).columns), | |
| 'missing_data': df.isnull().sum().to_dict(), | |
| 'duplicates': df.duplicated().sum(), | |
| 'memory_mb': round(df.memory_usage(deep=True).sum() / 1024**2, 2) | |
| } | |
| # Smart target detection with scoring | |
| target_scores = {} | |
| target_keywords = ['target', 'label', 'class', 'outcome', 'price', 'sales', 'churn', 'rating', 'status'] | |
| for col in df.columns: | |
| score = 0 | |
| col_lower = col.lower() | |
| # Keyword matching | |
| score += 15 if any(kw in col_lower for kw in target_keywords) else 0 | |
| # Statistical characteristics | |
| if col in profile['numeric_cols']: | |
| unique_ratio = df[col].nunique() / len(df) | |
| if 0.02 < unique_ratio < 0.95: # Good target range | |
| score += 10 | |
| if df[col].std() > 0: # Has variance | |
| score += 5 | |
| elif col in profile['categorical_cols']: | |
| unique_count = df[col].nunique() | |
| if 2 <= unique_count <= 20: # Good classification range | |
| score += 12 | |
| score += 5 if unique_count == 2 else 0 # Binary bonus | |
| # Position bias (targets often at end) | |
| if list(df.columns).index(col) >= len(df.columns) - 3: | |
| score += 3 | |
| target_scores[col] = score | |
| # Get top targets | |
| top_targets = sorted(target_scores.items(), key=lambda x: x[1], reverse=True)[:3] | |
| smart_targets = [col for col, score in top_targets if score > 8] | |
| # Generate ML recommendations for each target | |
| ml_recommendations = [] | |
| for target in smart_targets[:2]: # Top 2 targets | |
| target_type = 'numeric' if target in profile['numeric_cols'] else 'categorical' | |
| unique_vals = df[target].nunique() | |
| # Smart model selection based on actual data | |
| if target_type == 'numeric': | |
| skewness = df[target].skew() | |
| if abs(skewness) > 2: | |
| models = ['XGBoost Regressor', 'Random Forest', 'Gradient Boosting'] | |
| reason = f"Highly skewed data (skew: {skewness:.2f}) - tree models handle non-linearity" | |
| else: | |
| models = ['Linear Regression', 'Ridge/Lasso', 'Random Forest'] | |
| reason = f"Normal distribution - linear models suitable" | |
| else: | |
| if unique_vals == 2: | |
| models = ['Logistic Regression', 'XGBoost Classifier', 'Random Forest'] | |
| reason = f"Binary classification - balanced approach recommended" | |
| elif unique_vals <= 5: | |
| models = ['Multinomial Logistic', 'XGBoost', 'Random Forest'] | |
| reason = f"{unique_vals} classes - multi-class classification" | |
| else: | |
| models = ['XGBoost', 'Neural Networks', 'Random Forest'] | |
| reason = f"{unique_vals} classes - complex multi-class problem" | |
| ml_recommendations.append({ | |
| 'target': target, | |
| 'type': target_type, | |
| 'unique_vals': unique_vals, | |
| 'models': models, | |
| 'reason': reason, | |
| 'features': [c for c in df.columns if c != target] | |
| }) | |
| # Smart visualization recommendations | |
| viz_recs = [] | |
| # Executive KPIs | |
| for col in profile['numeric_cols'][:4]: | |
| viz_recs.append(f"📊 KPI Card: {col} (Current: {df[col].iloc[-1]:.2f}, Trend: {'↗️' if df[col].corr(pd.Series(range(len(df)))) > 0 else '↘️'})") | |
| # Comparative analysis | |
| for cat in profile['categorical_cols'][:2]: | |
| for num in profile['numeric_cols'][:2]: | |
| if df[cat].nunique() <= 10: | |
| avg_by_cat = df.groupby(cat)[num].mean().round(2).to_dict() | |
| viz_recs.append(f"📊 Bar Chart: {num} by {cat} - Averages: {avg_by_cat}") | |
| # Correlation insights | |
| if len(profile['numeric_cols']) >= 2: | |
| corr_matrix = df[profile['numeric_cols']].corr() | |
| strongest_corr = corr_matrix.abs().unstack().sort_values(ascending=False) | |
| strongest_corr = strongest_corr[strongest_corr < 1.0].head(3) | |
| for (var1, var2), corr_val in strongest_corr.items(): | |
| viz_recs.append(f"🔗 Scatter Plot: {var1} vs {var2} (Correlation: {corr_val:.3f})") | |
| # Distribution insights | |
| for col in profile['numeric_cols'][:3]: | |
| q1, q3 = df[col].quantile([0.25, 0.75]) | |
| outliers = len(df[(df[col] < q1 - 1.5*(q3-q1)) | (df[col] > q3 + 1.5*(q3-q1))]) | |
| viz_recs.append(f"📈 Histogram: {col} distribution (Outliers: {outliers}, Skew: {df[col].skew():.2f})") | |
| # Generate comprehensive report | |
| report = f"""# 🧠 INTELLIGENT DATASET ANALYSIS | |
| ## 📊 Dataset Intelligence | |
| **Rows:** {profile['shape'][0]:,} | **Columns:** {profile['shape'][1]} | **Size:** {profile['memory_mb']} MB | **Duplicates:** {profile['duplicates']} | |
| **Data Quality Score:** {((len(df) - sum(profile['missing_data'].values())) / (len(df) * len(df.columns)) * 100):.1f}% | |
| ## 🎯 SMART TARGET DETECTION | |
| """ | |
| for i, (target, score) in enumerate(top_targets[:3], 1): | |
| target_info = f"**{i}. {target}** (Confidence: {score}/20)" | |
| if target in smart_targets: | |
| target_info += f" ✅ **RECOMMENDED**" | |
| if target in profile['numeric_cols']: | |
| target_info += f" | Values: {df[target].min():.2f} - {df[target].max():.2f} | Mean: {df[target].mean():.2f}" | |
| else: | |
| top_values = df[target].value_counts().head(3).to_dict() | |
| target_info += f" | Top categories: {top_values}" | |
| report += f"{target_info}\n" | |
| report += f"\n## 🤖 ML MODEL RECOMMENDATIONS\n" | |
| for i, rec in enumerate(ml_recommendations, 1): | |
| report += f"""### Scenario {i}: Predict `{rec['target']}` | |
| **Problem Type:** {rec['type'].upper()} {'REGRESSION' if rec['type'] == 'numeric' else 'CLASSIFICATION'} | |
| **AI Reasoning:** {rec['reason']} | |
| **Recommended Models:** | |
| 1. 🥇 **{rec['models'][0]}** (Primary choice) | |
| 2. 🥈 **{rec['models'][1]}** (Alternative) | |
| 3. 🥉 **{rec['models'][2]}** (Backup option) | |
| **Features Available:** {len(rec['features'])} variables | |
| **Data Split:** {int(len(df)*0.8):,} train / {int(len(df)*0.2):,} test | |
| """ | |
| # Data preprocessing recommendations | |
| missing_cols = [col for col, missing in profile['missing_data'].items() if missing > 0] | |
| high_cardinality = [col for col in profile['categorical_cols'] if df[col].nunique() > 20] | |
| report += f"""## ⚙️ PREPROCESSING PIPELINE | |
| **Missing Data:** {len(missing_cols)} columns need attention | |
| """ | |
| if missing_cols: | |
| for col in missing_cols[:5]: | |
| missing_pct = (profile['missing_data'][col] / len(df)) * 100 | |
| strategy = "Drop column" if missing_pct > 50 else ("Median fill" if col in profile['numeric_cols'] else "Mode fill") | |
| report += f"- `{col}`: {missing_pct:.1f}% missing → {strategy}\n" | |
| if high_cardinality: | |
| report += f"**High Cardinality:** {len(high_cardinality)} categorical columns need encoding\n" | |
| for col in high_cardinality[:3]: | |
| report += f"- `{col}`: {df[col].nunique()} categories → Target encoding recommended\n" | |
| report += f"\n## 📊 SMART VISUALIZATIONS\n" | |
| for viz in viz_recs: | |
| report += f"{viz}\n" | |
| # Performance predictions | |
| sample_size_category = "Large" if len(df) > 50000 else ("Medium" if len(df) > 5000 else "Small") | |
| feature_ratio = len(df.columns) / len(df) | |
| report += f""" | |
| ## 🚀 IMPLEMENTATION ROADMAP | |
| ### Phase 1: Data Preparation (Week 1) | |
| - Handle {len(missing_cols)} missing data issues | |
| - Encode {len(profile['categorical_cols'])} categorical variables | |
| - Feature scaling for {len(profile['numeric_cols'])} numeric variables | |
| ### Phase 2: Model Development (Week 2-3) | |
| - {sample_size_category} dataset → Expected training time: {'Minutes' if len(df) < 10000 else 'Hours'} | |
| - Feature importance analysis using top recommended models | |
| - Cross-validation with {5 if len(df) > 1000 else 3}-fold strategy | |
| ### Phase 3: Production (Week 4) | |
| - Model deployment pipeline | |
| - Performance monitoring dashboard | |
| - A/B testing framework | |
| ## 💡 BUSINESS IMPACT PREDICTION | |
| **Model Accuracy Expectation:** {85 if len(df) > 10000 and len(missing_cols) < 3 else 75}%+ | |
| **ROI Timeline:** 3-6 months | |
| **Automation Potential:** {min(90, len(profile['numeric_cols']) * 10)}% of manual analysis | |
| """ | |
| return report | |
| except Exception as e: | |
| return f"Analysis failed: {str(e)}\nEnsure file is valid CSV/Excel format." | |
| def smart_ba_chat(message, history): | |
| """Intelligent BA assistant with contextual responses""" | |
| # Smart response generation based on keywords | |
| keywords = message.lower() | |
| if any(word in keywords for word in ['requirement', 'functional', 'specification']): | |
| response = f"""## 📋 Smart Requirements Analysis for: "{message}" | |
| ### 🎯 Identified Requirements Type | |
| **Primary:** {'Functional' if 'function' in keywords else 'Business'} Requirements | |
| **Complexity:** {'High' if len(message.split()) > 20 else 'Medium'} | |
| ### 📝 Generated Requirements Framework | |
| 1. **Must Have (P1)** | |
| - Core functionality: {message.split('.')[0] if '.' in message else message[:50]} | |
| - User authentication and authorization | |
| - Data validation and error handling | |
| 2. **Should Have (P2)** | |
| - Reporting and analytics dashboard | |
| - Export/import capabilities | |
| - Audit trail functionality | |
| 3. **Could Have (P3)** | |
| - Advanced filtering options | |
| - Mobile responsiveness | |
| - Integration APIs | |
| ### ✅ Acceptance Criteria Template | |
| ``` | |
| Given: User has appropriate permissions | |
| When: User performs {message.split()[-1] if message.split() else 'action'} | |
| Then: System should respond within 3 seconds | |
| And: Changes should be logged for audit | |
| ``` | |
| ### 🔍 Next Steps | |
| - [ ] Stakeholder validation workshop | |
| - [ ] Technical feasibility assessment | |
| - [ ] Resource estimation and timeline | |
| """ | |
| elif any(word in keywords for word in ['process', 'workflow', 'procedure']): | |
| response = f"""## 🔄 Process Analysis for: "{message}" | |
| ### 📊 Current State Assessment | |
| **Process Complexity:** {'High' if 'complex' in keywords or 'multiple' in keywords else 'Medium'} | |
| **Stakeholders Involved:** {'Multiple departments' if 'department' in keywords else 'Single team'} | |
| ### 🎯 Identified Pain Points | |
| - Manual handoffs and delays | |
| - Lack of visibility and tracking | |
| - Inconsistent execution | |
| - No performance metrics | |
| ### 🚀 Recommended Solution | |
| **Automation Level:** {80 if 'automate' in keywords else 60}% | |
| **Expected Efficiency Gain:** {40 if 'improve' in keywords else 25}% | |
| **Implementation Timeline:** {'3-6 months' if 'large' in keywords else '6-12 weeks'} | |
| ### 📈 Process Optimization Steps | |
| 1. **Map Current State** (Week 1-2) | |
| 2. **Identify Bottlenecks** (Week 3) | |
| 3. **Design Future State** (Week 4-5) | |
| 4. **Pilot Implementation** (Week 6-8) | |
| 5. **Full Rollout** (Week 9-12) | |
| ### 🎯 Success Metrics | |
| - Process cycle time reduction: 50%+ | |
| - Error rate reduction: 80%+ | |
| - User satisfaction score: 4.5+/5 | |
| """ | |
| elif any(word in keywords for word in ['dashboard', 'report', 'visual', 'chart']): | |
| response = f"""## 📊 Visualization Strategy for: "{message}" | |
| ### 🎨 Smart Chart Recommendations | |
| **Data Type Detected:** {'Time-series' if 'time' in keywords or 'trend' in keywords else 'Categorical'} | |
| **Audience Level:** {'Executive' if 'executive' in keywords else 'Operational'} | |
| ### 📈 Recommended Visualizations | |
| 1. **KPI Dashboard** | |
| - Primary metrics with trend indicators | |
| - Color-coded status (Red/Yellow/Green) | |
| - Real-time data refresh | |
| 2. **Comparative Analysis** | |
| - Bar charts for category comparison | |
| - Heat maps for correlation analysis | |
| - Scatter plots for relationship insights | |
| 3. **Trend Analysis** | |
| - Line charts for time-based data | |
| - Area charts for cumulative metrics | |
| - Waterfall charts for variance analysis | |
| ### 🎯 Dashboard Layout Strategy | |
| ``` | |
| ┌─────────────────────────────────────────┐ | |
| │ Executive Summary KPIs │ | |
| ├─────────────────┬───────────────────────┤ | |
| │ Primary Chart │ Filter Controls │ | |
| │ (60% width) │ & Drill-downs │ | |
| ├─────────────────┴───────────────────────┤ | |
| │ Supporting Analytics │ | |
| └─────────────────────────────────────────┘ | |
| ``` | |
| ### 💡 Business Intelligence Features | |
| - Interactive filtering and drill-down | |
| - Automated insights and anomaly detection | |
| - Mobile-responsive design | |
| - Export capabilities (PDF, Excel, PowerPoint) | |
| """ | |
| else: | |
| # Generic intelligent response | |
| response = f"""## 🧠 Smart Business Analysis for: "{message}" | |
| ### 🎯 Analysis Summary | |
| **Domain:** {'Technology' if any(tech in keywords for tech in ['system', 'software', 'digital', 'ai', 'ml']) else 'Business Operations'} | |
| **Complexity:** {'High' if len(message.split()) > 15 else 'Medium'} | |
| **Urgency:** {'High' if any(urgent in keywords for urgent in ['urgent', 'asap', 'critical']) else 'Normal'} | |
| ### 📊 Key Considerations | |
| 1. **Stakeholder Impact Analysis** | |
| - Primary users: Business operations team | |
| - Secondary users: Management and IT | |
| - Decision makers: Department heads | |
| 2. **Success Criteria Definition** | |
| - Quantitative: ROI > 20%, Time savings > 30% | |
| - Qualitative: User satisfaction, Process efficiency | |
| - Timeline: {'6-8 weeks' if 'quick' in keywords else '3-4 months'} | |
| 3. **Risk Assessment** | |
| - Technical: {'Medium' if 'technical' in keywords else 'Low'} | |
| - Business: {'High' if 'change' in keywords else 'Medium'} | |
| - Resource: Based on scope and timeline | |
| ### 🚀 Recommended Action Plan | |
| **Phase 1:** Requirement gathering and stakeholder alignment | |
| **Phase 2:** Solution design and prototype development | |
| **Phase 3:** Implementation and testing | |
| **Phase 4:** Deployment and change management | |
| ### 💡 Next Steps | |
| - Schedule stakeholder interviews | |
| - Define detailed acceptance criteria | |
| - Create project timeline and milestones | |
| - Identify potential risks and mitigation strategies | |
| """ | |
| return response | |
| # Streamlined Gradio Interface | |
| with gr.Blocks(title="Smart Business Analyst GPT", theme=gr.themes.Soft()) as demo: | |
| gr.Markdown("# 🧠 Smart Business Analyst GPT\n## AI-Powered Dataset Analysis & Business Intelligence") | |
| with gr.Tabs(): | |
| with gr.TabItem("💬 Intelligent BA Assistant"): | |
| chatbot = gr.Chatbot(height=500, label="Smart BA Assistant") | |
| msg = gr.Textbox(placeholder="Describe your business challenge...", label="Your Question", lines=2) | |
| with gr.Row(): | |
| submit = gr.Button("🚀 Get Smart Analysis", variant="primary") | |
| clear = gr.Button("Clear") | |
| with gr.TabItem("📊 Complete Dataset Analysis"): | |
| gr.Markdown("### Upload your dataset for comprehensive AI analysis") | |
| file_upload = gr.File(label="Upload CSV/Excel", file_types=[".csv", ".xlsx", ".xls"]) | |
| analyze_btn = gr.Button("🧠 Complete Analysis", variant="primary", size="lg") | |
| analysis_output = gr.Textbox(label="Intelligent Analysis Report", lines=30, show_copy_button=True) | |
| # Event handlers | |
| def chat_respond(message, history): | |
| response = smart_ba_chat(message, history) | |
| history.append((message, response)) | |
| return "", history | |
| msg.submit(chat_respond, [msg, chatbot], [msg, chatbot]) | |
| submit.click(chat_respond, [msg, chatbot], [msg, chatbot]) | |
| clear.click(lambda: [], None, chatbot) | |
| analyze_btn.click(smart_dataset_analysis, file_upload, analysis_output) | |
| if __name__ == "__main__": | |
| demo.launch() |