AI Data Analysis: วิเคราะห์ข้อมูลธุรกิจด้วย AI

AI ช่วยให้ธุรกิจวิเคราะห์ข้อมูลได้เร็วขึ้นและค้นพบ insights ที่ซ่อนอยู่

ทำไมต้องใช้ AI วิเคราะห์ข้อมูล?

Traditional vs AI Analysis

Traditional Analysis:
- ต้องมี Data Analyst
- ใช้เวลานาน (วัน-สัปดาห์)
- ดูได้เฉพาะ metrics ที่กำหนด
- Limited pattern recognition

AI-Powered Analysis:
- ทุกคนใช้ได้ (natural language)
- ผลลัพธ์ใน seconds
- ค้นพบ insights ใหม่ๆ
- Complex pattern detection

Use Cases

1. Sales Analysis
   - Revenue trends
   - Product performance
   - Sales forecasting

2. Customer Analysis
   - Behavior patterns
   - Churn prediction
   - Lifetime value

3. Operations
   - Cost analysis
   - Efficiency metrics
   - Process optimization

4. Marketing
   - Campaign ROI
   - Channel attribution
   - Customer segmentation

Natural Language Data Queries

Chat with Your Data

from openai import OpenAI
import pandas as pd

client = OpenAI()

def analyze_data_with_ai(df, question):
    # Convert dataframe info to context
    data_context = f"""
Dataset Info:
- Columns: {list(df.columns)}
- Rows: {len(df)}
- Sample data:
{df.head(3).to_string()}

Summary statistics:
{df.describe().to_string()}
"""

    prompt = f"""
You are a data analyst. Analyze this dataset and answer the question.

{data_context}

Question: {question}

Provide:
1. Direct answer to the question
2. Key insights discovered
3. Recommended actions based on data
4. Visualizations that would help (describe them)
"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

# Usage
sales_df = pd.read_csv("sales_data.csv")
result = analyze_data_with_ai(sales_df, "สินค้าไหนขายดีที่สุดเดือนนี้?")
print(result)

SQL Generation

def generate_sql_query(question, schema):
    prompt = f"""
Generate a SQL query based on this question:
"{question}"

Database Schema:
{schema}

Requirements:
- Use proper SQL syntax
- Include appropriate JOINs if needed
- Add comments explaining the query
- Consider performance (use indexes, avoid SELECT *)
"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

Automated Report Generation

Daily/Weekly Reports

class AutomatedReportGenerator:
    def __init__(self, data_source):
        self.data = data_source

    def generate_daily_report(self, date):
        # Fetch data
        daily_data = self.data.get_daily_metrics(date)

        prompt = f"""
Generate a daily business report for {date}

Data:
- Revenue: ${daily_data['revenue']:,}
- Orders: {daily_data['orders']}
- New Customers: {daily_data['new_customers']}
- Avg Order Value: ${daily_data['aov']:.2f}
- Top Products: {daily_data['top_products']}
- Conversion Rate: {daily_data['conversion_rate']:.2%}

Compare to:
- Yesterday: {daily_data['vs_yesterday']}
- Same day last week: {daily_data['vs_last_week']}
- Same day last month: {daily_data['vs_last_month']}

Provide:
1. Executive Summary (3 bullets)
2. Key Highlights
3. Areas of Concern
4. Recommended Actions
"""

        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}]
        )

        return response.choices[0].message.content

    def generate_weekly_insights(self, week_data):
        prompt = f"""
Analyze this week's business performance:

{week_data}

Provide:
1. Week-over-week trends
2. Pattern identification
3. Anomaly detection
4. Predictions for next week
5. Strategic recommendations
"""

        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[{"role": "user", "content": prompt}]
        )

        return response.choices[0].message.content

Customer Analysis

Segmentation

def analyze_customer_segments(customer_data):
    prompt = f"""
Analyze customer data and suggest segmentation:

Customer Data Summary:
- Total customers: {customer_data['total']}
- Average purchase frequency: {customer_data['avg_frequency']}
- Average order value: ${customer_data['avg_aov']}
- Lifetime value distribution: {customer_data['ltv_distribution']}
- Purchase categories: {customer_data['categories']}

RFM Analysis:
{customer_data['rfm_summary']}

Suggest:
1. Customer segments (with names and descriptions)
2. Characteristics of each segment
3. Size of each segment
4. Marketing strategy for each
5. Cross-sell/upsell opportunities
"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

Churn Prediction Analysis

def analyze_churn_risk(customer_behavior):
    prompt = f"""
Analyze customer behavior for churn risk:

Behavior Patterns:
{customer_behavior}

Identify:
1. High-risk churn indicators
2. Customer groups at risk
3. Estimated revenue at risk
4. Early warning signs
5. Retention recommendations

Provide actionable insights for:
- Immediate interventions
- Long-term retention strategies
- Win-back campaigns
"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

Financial Analysis

Revenue Forecasting

def generate_revenue_forecast(historical_data, external_factors):
    prompt = f"""
Generate revenue forecast based on:

Historical Revenue (last 12 months):
{historical_data}

External Factors:
- Seasonality: {external_factors['seasonality']}
- Market trends: {external_factors['market_trends']}
- Planned campaigns: {external_factors['campaigns']}
- Economic outlook: {external_factors['economic']}

Provide:
1. 3-month forecast (monthly breakdown)
2. 6-month forecast
3. Confidence intervals
4. Key assumptions
5. Risk factors
6. Scenario analysis (best/base/worst case)
"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

Cost Analysis

def analyze_costs(cost_data):
    prompt = f"""
Analyze business costs and identify optimization opportunities:

Cost Breakdown:
{cost_data['breakdown']}

Trends (last 6 months):
{cost_data['trends']}

Industry Benchmarks:
{cost_data['benchmarks']}

Identify:
1. Cost structure analysis
2. Areas of overspending
3. Cost optimization opportunities
4. ROI of major expenses
5. Recommendations with estimated savings
"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

Competitive Analysis

Market Intelligence

def analyze_competitive_landscape(market_data):
    prompt = f"""
Analyze competitive landscape:

Our Performance:
{market_data['our_metrics']}

Competitor Data:
{market_data['competitors']}

Market Trends:
{market_data['trends']}

Provide:
1. Market position analysis
2. Competitive strengths/weaknesses
3. Market opportunities
4. Threat assessment
5. Strategic recommendations
6. Quick wins vs long-term initiatives
"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

Data Quality Analysis

Automated Data Validation

def analyze_data_quality(df):
    # Calculate data quality metrics
    quality_metrics = {
        "total_rows": len(df),
        "missing_values": df.isnull().sum().to_dict(),
        "duplicates": df.duplicated().sum(),
        "data_types": df.dtypes.to_dict(),
        "unique_counts": {col: df[col].nunique() for col in df.columns}
    }

    prompt = f"""
Analyze data quality and suggest improvements:

Data Quality Metrics:
{quality_metrics}

Sample Data Issues Found:
- Missing values: {sum(quality_metrics['missing_values'].values())}
- Duplicate rows: {quality_metrics['duplicates']}

Provide:
1. Overall data quality score (0-100)
2. Critical issues that need immediate attention
3. Data cleaning recommendations
4. Potential impact on analysis accuracy
5. Data governance suggestions
"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

Dashboard Insights

KPI Interpretation

def interpret_dashboard_kpis(kpi_data):
    prompt = f"""
Interpret these KPIs for non-technical stakeholders:

Current KPIs:
{kpi_data['current']}

Previous Period:
{kpi_data['previous']}

Targets:
{kpi_data['targets']}

Provide:
1. Plain English explanation of each KPI
2. What's going well (green flags)
3. What needs attention (red flags)
4. Likely causes for changes
5. Recommended next steps
6. Questions to investigate further
"""

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}]
    )

    return response.choices[0].message.content

Integration with BI Tools

Automated Insights

class AIAnalyticsIntegration:
    def __init__(self, bi_connection):
        self.bi = bi_connection

    def get_ai_insights(self, dashboard_id):
        # Fetch dashboard data
        data = self.bi.get_dashboard_data(dashboard_id)

        # Generate AI insights
        insights = self._generate_insights(data)

        # Return structured response
        return {
            "summary": insights['summary'],
            "key_findings": insights['findings'],
            "recommendations": insights['recommendations'],
            "alerts": insights['alerts']
        }

    def schedule_insights(self, schedule, recipients):
        # Set up automated insight delivery
        pass

    def anomaly_detection(self, metric, timeframe):
        # Detect anomalies in metrics
        data = self.bi.get_metric_history(metric, timeframe)
        return self._detect_anomalies(data)

Best Practices

1. Data Preparation

Before AI Analysis:
✅ Clean data (remove duplicates, fix errors)
✅ Standardize formats
✅ Handle missing values
✅ Validate data accuracy

2. Ask the Right Questions

Good Questions:
- "What factors correlate with high customer LTV?"
- "Why did sales drop in Q3?"
- "Which products have declining margins?"

Bad Questions:
- "Tell me about my data" (too vague)
- "Predict next year's revenue exactly" (too specific)

3. Validate AI Insights

Always verify:
- Do numbers match source data?
- Are correlations causal?
- Consider business context
- Cross-check with domain experts

สรุป

AI Data Analysis Benefits:

1. Speed: วิเคราะห์ได้ในวินาที
2. Accessibility: ทุกคนใช้ได้ ไม่ต้องเขียน SQL
3. Insights: ค้นพบ patterns ใหม่ๆ
4. Automation: รายงานอัตโนมัติ
5. Scale: วิเคราะห์ข้อมูลขนาดใหญ่ได้

Key Applications:

• Natural language queries
• Automated reports
• Customer segmentation
• Forecasting
• Anomaly detection

Remember:

• Clean data = Better insights
• Verify AI conclusions
• Combine with human judgment
• Start with clear questions

---

อ่านเพิ่มเติม:

• AI ROI Calculation
• AI Implementation Roadmap
• Vector Database for AI