Add chapter-02-data-modeling/lab-02-medallion.py

chapter-02-data-modeling/lab-02-medallion.py

@@ -0,0 +1,549 @@
+"""
+Lab 2b: Medallion Architecture Implementation
+==============================================
+BIM5021 - Nhà kho dữ liệu và Tích hợp
+Chương 2: Mô hình hóa dữ liệu cho Cloud Warehousing
+
+Mục tiêu:
+- Implement Medallion Architecture (Bronze → Silver → Gold) bằng Python + Pandas
+- Mô phỏng quy trình ETL/ELT cho Olist dataset
+- Xử lý data quality ở mỗi tầng
+
+Yêu cầu: pip install pandas numpy
+Dataset: Olist Brazilian E-commerce (download từ Kaggle)
+"""
+
+import pandas as pd
+import numpy as np
+import os
+import json
+from datetime import datetime
+
+# ==============================================================================
+# CẤU HÌNH
+# ==============================================================================
+
+# Đường dẫn đến thư mục chứa CSV files của Olist
+# Download từ: https://www.kaggle.com/datasets/olistbr/brazilian-ecommerce
+DATA_DIR = os.environ.get('OLIST_DATA_DIR', './data/raw/')
+OUTPUT_DIR = os.environ.get('OUTPUT_DIR', './data/')
+
+# Tạo thư mục output
+for layer in ['bronze', 'silver', 'gold']:
+    os.makedirs(f'{OUTPUT_DIR}/{layer}', exist_ok=True)
+
+
+# ==============================================================================
+# BRONZE LAYER: Raw Data Ingestion
+# ==============================================================================
+
+class BronzeLayer:
+    """
+    Bronze Layer: Ingest raw data as-is.
+    - Không transform
+    - Chỉ thêm metadata (ingestion timestamp, source file)
+    - Lưu dưới dạng Parquet (columnar, compressed)
+    """
+    
+    def __init__(self, data_dir: str, output_dir: str):
+        self.data_dir = data_dir
+        self.output_dir = f'{output_dir}/bronze'
+        self.ingestion_log = []
+    
+    def ingest_csv(self, filename: str, table_name: str) -> pd.DataFrame:
+        """Ingest 1 CSV file vào Bronze layer."""
+        filepath = os.path.join(self.data_dir, filename)
+        
+        if not os.path.exists(filepath):
+            print(f"  [SKIP] File not found: {filepath}")
+            print(f"         Download Olist dataset from Kaggle first!")
+            # Tạo sample data để demo
+            return self._create_sample_data(table_name)
+        
+        # Read raw CSV
+        df = pd.read_csv(filepath)
+        
+        # Add metadata columns (Bronze standard)
+        df['_ingested_at'] = datetime.now().isoformat()
+        df['_source_file'] = filename
+        df['_row_hash'] = df.apply(lambda row: hash(tuple(row)), axis=1)
+        
+        # Save as Parquet
+        output_path = f'{self.output_dir}/{table_name}.parquet'
+        df.to_parquet(output_path, index=False)
+        
+        # Log
+        log_entry = {
+            'table': table_name,
+            'source': filename,
+            'rows': len(df),
+            'columns': len(df.columns),
+            'size_mb': os.path.getsize(output_path) / (1024*1024),
+            'ingested_at': datetime.now().isoformat()
+        }
+        self.ingestion_log.append(log_entry)
+        
+        print(f"  [BRONZE] {table_name}: {len(df):,} rows, "
+              f"{len(df.columns)} cols → {output_path}")
+        
+        return df
+    
+    def _create_sample_data(self, table_name: str) -> pd.DataFrame:
+        """Tạo sample data khi không có file thật (cho demo)."""
+        np.random.seed(42)
+        
+        sample_data = {
+            'orders': pd.DataFrame({
+                'order_id': [f'ord_{i:05d}' for i in range(100)],
+                'customer_id': [f'cust_{np.random.randint(1, 50):04d}' for _ in range(100)],
+                'order_status': np.random.choice(
+                    ['delivered', 'shipped', 'canceled', 'processing'],
+                    100, p=[0.8, 0.1, 0.05, 0.05]
+                ),
+                'order_purchase_timestamp': pd.date_range(
+                    '2017-01-01', periods=100, freq='3D'
+                ).strftime('%Y-%m-%d %H:%M:%S'),
+                'order_delivered_customer_date': [
+                    (pd.Timestamp('2017-01-01') + pd.Timedelta(days=i*3+np.random.randint(3, 15)))
+                    .strftime('%Y-%m-%d %H:%M:%S') if np.random.random() > 0.1 else None
+                    for i in range(100)
+                ],
+            }),
+            'order_items': pd.DataFrame({
+                'order_id': [f'ord_{np.random.randint(0, 100):05d}' for _ in range(150)],
+                'order_item_id': np.random.randint(1, 5, 150),
+                'product_id': [f'prod_{np.random.randint(1, 30):03d}' for _ in range(150)],
+                'seller_id': [f'seller_{np.random.randint(1, 10):03d}' for _ in range(150)],
+                'price': np.round(np.random.uniform(10, 500, 150), 2),
+                'freight_value': np.round(np.random.uniform(5, 80, 150), 2),
+            }),
+            'customers': pd.DataFrame({
+                'customer_id': [f'cust_{i:04d}' for i in range(50)],
+                'customer_unique_id': [f'unique_{i:04d}' for i in range(50)],
+                'customer_zip_code_prefix': np.random.randint(10000, 99999, 50).astype(str),
+                'customer_city': np.random.choice(
+                    ['sao paulo', 'rio de janeiro', 'belo horizonte', 'brasilia', 'curitiba'],
+                    50
+                ),
+                'customer_state': np.random.choice(['SP', 'RJ', 'MG', 'DF', 'PR'], 50),
+            }),
+        }
+        
+        df = sample_data.get(table_name, pd.DataFrame({'id': range(10)}))
+        df['_ingested_at'] = datetime.now().isoformat()
+        df['_source_file'] = f'sample_{table_name}.csv'
+        
+        print(f"  [BRONZE] {table_name}: {len(df):,} rows (SAMPLE DATA)")
+        return df
+    
+    def ingest_all(self) -> dict:
+        """Ingest tất cả files của Olist dataset."""
+        print("\n" + "=" * 60)
+        print("  BRONZE LAYER - Raw Data Ingestion")
+        print("=" * 60)
+        
+        files = {
+            'orders': 'olist_orders_dataset.csv',
+            'order_items': 'olist_order_items_dataset.csv',
+            'customers': 'olist_customers_dataset.csv',
+            'products': 'olist_products_dataset.csv',
+            'sellers': 'olist_sellers_dataset.csv',
+            'payments': 'olist_order_payments_dataset.csv',
+            'reviews': 'olist_order_reviews_dataset.csv',
+            'geolocation': 'olist_geolocation_dataset.csv',
+            'category_translation': 'product_category_name_translation.csv',
+        }
+        
+        bronze_tables = {}
+        for table_name, filename in files.items():
+            bronze_tables[table_name] = self.ingest_csv(filename, table_name)
+        
+        print(f"\n  Total: {sum(len(df) for df in bronze_tables.values()):,} rows ingested")
+        return bronze_tables
+
+
+# ==============================================================================
+# SILVER LAYER: Cleansed & Conformed Data
+# ==============================================================================
+
+class SilverLayer:
+    """
+    Silver Layer: Clean, validate, and conform data.
+    - Data type casting
+    - Null handling
+    - Deduplication
+    - Standardization
+    - Business rules validation
+    """
+    
+    def __init__(self, output_dir: str):
+        self.output_dir = f'{output_dir}/silver'
+        self.quality_report = {}
+    
+    def process_orders(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Clean orders table."""
+        print(f"\n  [SILVER] Processing orders...")
+        
+        original_count = len(df)
+        report = {'table': 'orders', 'original_rows': original_count}
+        
+        # 1. Remove metadata columns from bronze
+        meta_cols = [c for c in df.columns if c.startswith('_')]
+        df = df.drop(columns=meta_cols, errors='ignore')
+        
+        # 2. Deduplicate
+        df = df.drop_duplicates(subset=['order_id'])
+        report['after_dedup'] = len(df)
+        
+        # 3. Cast timestamps
+        timestamp_cols = [c for c in df.columns if 'timestamp' in c or 'date' in c]
+        for col in timestamp_cols:
+            df[col] = pd.to_datetime(df[col], errors='coerce')
+        
+        # 4. Validate order_status
+        valid_statuses = ['delivered', 'shipped', 'canceled', 'unavailable',
+                         'invoiced', 'processing', 'created', 'approved']
+        invalid_mask = ~df['order_status'].isin(valid_statuses)
+        report['invalid_status'] = int(invalid_mask.sum())
+        df.loc[invalid_mask, 'order_status'] = 'unknown'
+        
+        # 5. Validate business rules
+        # - purchase_timestamp should exist
+        null_purchase = df['order_purchase_timestamp'].isna()
+        report['null_purchase_ts'] = int(null_purchase.sum())
+        df = df[~null_purchase]  # Remove orders without purchase date
+        
+        # 6. Add derived columns
+        if 'order_delivered_customer_date' in df.columns and 'order_purchase_timestamp' in df.columns:
+            df['delivery_days'] = (
+                df['order_delivered_customer_date'] - df['order_purchase_timestamp']
+            ).dt.total_seconds() / 86400
+            df['delivery_days'] = df['delivery_days'].round(1)
+        
+        # 7. Add silver metadata
+        df['_processed_at'] = datetime.now().isoformat()
+        
+        report['final_rows'] = len(df)
+        report['rows_removed'] = original_count - len(df)
+        self.quality_report['orders'] = report
+        
+        # Save
+        output_path = f'{self.output_dir}/silver_orders.parquet'
+        df.to_parquet(output_path, index=False)
+        
+        print(f"    Original: {original_count:,} → Cleaned: {len(df):,} "
+              f"(removed {original_count - len(df):,})")
+        
+        return df
+    
+    def process_customers(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Clean customers table."""
+        print(f"  [SILVER] Processing customers...")
+        
+        original_count = len(df)
+        meta_cols = [c for c in df.columns if c.startswith('_')]
+        df = df.drop(columns=meta_cols, errors='ignore')
+        
+        # Deduplicate by customer_id (keep first)
+        df = df.drop_duplicates(subset=['customer_id'], keep='first')
+        
+        # Standardize city names
+        if 'customer_city' in df.columns:
+            df['customer_city'] = (
+                df['customer_city']
+                .str.strip()
+                .str.lower()
+                .str.title()
+            )
+        
+        # Standardize state codes
+        if 'customer_state' in df.columns:
+            df['customer_state'] = df['customer_state'].str.upper().str.strip()
+        
+        df['_processed_at'] = datetime.now().isoformat()
+        
+        output_path = f'{self.output_dir}/silver_customers.parquet'
+        df.to_parquet(output_path, index=False)
+        
+        print(f"    Original: {original_count:,} → Cleaned: {len(df):,}")
+        return df
+    
+    def process_order_items(self, df: pd.DataFrame) -> pd.DataFrame:
+        """Clean order_items table."""
+        print(f"  [SILVER] Processing order_items...")
+        
+        original_count = len(df)
+        meta_cols = [c for c in df.columns if c.startswith('_')]
+        df = df.drop(columns=meta_cols, errors='ignore')
+        
+        # Cast numeric
+        for col in ['price', 'freight_value']:
+            if col in df.columns:
+                df[col] = pd.to_numeric(df[col], errors='coerce')
+        
+        # Remove negative prices
+        if 'price' in df.columns:
+            df = df[df['price'] >= 0]
+        
+        # Add total_value
+        if 'price' in df.columns and 'freight_value' in df.columns:
+            df['total_value'] = df['price'] + df['freight_value'].fillna(0)
+        
+        df['_processed_at'] = datetime.now().isoformat()
+        
+        output_path = f'{self.output_dir}/silver_order_items.parquet'
+        df.to_parquet(output_path, index=False)
+        
+        print(f"    Original: {original_count:,} → Cleaned: {len(df):,}")
+        return df
+    
+    def process_all(self, bronze_tables: dict) -> dict:
+        """Process tất cả bronze tables → silver."""
+        print("\n" + "=" * 60)
+        print("  SILVER LAYER - Data Cleansing & Conforming")
+        print("=" * 60)
+        
+        silver = {}
+        
+        if 'orders' in bronze_tables:
+            silver['orders'] = self.process_orders(bronze_tables['orders'])
+        
+        if 'customers' in bronze_tables:
+            silver['customers'] = self.process_customers(bronze_tables['customers'])
+        
+        if 'order_items' in bronze_tables:
+            silver['order_items'] = self.process_order_items(bronze_tables['order_items'])
+        
+        # Print quality report
+        print(f"\n  Quality Report:")
+        for table, report in self.quality_report.items():
+            print(f"    {table}: {report}")
+        
+        return silver
+
+
+# ==============================================================================
+# GOLD LAYER: Business-Ready Data
+# ==============================================================================
+
+class GoldLayer:
+    """
+    Gold Layer: Business-ready aggregations and star schema.
+    - Star Schema (dims + facts)
+    - Pre-computed aggregations
+    - KPI tables
+    - ML-ready feature tables
+    """
+    
+    def __init__(self, output_dir: str):
+        self.output_dir = f'{output_dir}/gold'
+    
+    def create_dim_time(self, silver_orders: pd.DataFrame) -> pd.DataFrame:
+        """Tạo dim_time từ range ngày trong orders."""
+        print(f"\n  [GOLD] Creating dim_time...")
+        
+        if 'order_purchase_timestamp' in silver_orders.columns:
+            min_date = silver_orders['order_purchase_timestamp'].min()
+            max_date = silver_orders['order_purchase_timestamp'].max()
+            
+            # Nếu là string, convert
+            if isinstance(min_date, str):
+                min_date = pd.Timestamp(min_date)
+                max_date = pd.Timestamp(max_date)
+        else:
+            min_date = pd.Timestamp('2017-01-01')
+            max_date = pd.Timestamp('2018-12-31')
+        
+        dates = pd.date_range(
+            start=min_date.normalize(),
+            end=max_date.normalize() + pd.Timedelta(days=30),
+            freq='D'
+        )
+        
+        dim_time = pd.DataFrame({
+            'time_key': dates.strftime('%Y%m%d').astype(int),
+            'full_date': dates.date,
+            'day_of_week': dates.dayofweek + 1,
+            'day_name': dates.day_name(),
+            'day_of_month': dates.day,
+            'week_of_year': dates.isocalendar().week.values,
+            'month_number': dates.month,
+            'month_name': dates.month_name(),
+            'quarter': dates.quarter,
+            'year': dates.year,
+            'is_weekend': dates.dayofweek >= 5,
+        })
+        
+        output_path = f'{self.output_dir}/dim_time.parquet'
+        dim_time.to_parquet(output_path, index=False)
+        print(f"    dim_time: {len(dim_time):,} rows ({dates[0].date()} → {dates[-1].date()})")
+        
+        return dim_time
+    
+    def create_agg_daily_revenue(self, silver_orders: pd.DataFrame, 
+                                  silver_items: pd.DataFrame) -> pd.DataFrame:
+        """Tạo bảng aggregate doanh thu theo ngày."""
+        print(f"  [GOLD] Creating agg_daily_revenue...")
+        
+        # Ensure datetime
+        if 'order_purchase_timestamp' in silver_orders.columns:
+            silver_orders['purchase_date'] = pd.to_datetime(
+                silver_orders['order_purchase_timestamp']
+            ).dt.date
+        
+            # Merge orders with items
+            merged = silver_items.merge(
+                silver_orders[['order_id', 'purchase_date', 'order_status']],
+                on='order_id',
+                how='inner'
+            )
+            
+            # Aggregate by day
+            daily = merged.groupby('purchase_date').agg(
+                total_orders=('order_id', 'nunique'),
+                total_items=('order_id', 'count'),
+                total_revenue=('price', 'sum'),
+                total_freight=('freight_value', 'sum'),
+                avg_price=('price', 'mean'),
+            ).reset_index()
+            
+            daily['avg_order_value'] = daily['total_revenue'] / daily['total_orders']
+            daily = daily.round(2)
+        else:
+            # Sample data fallback
+            dates = pd.date_range('2017-01-01', periods=30, freq='D')
+            daily = pd.DataFrame({
+                'purchase_date': dates.date,
+                'total_orders': np.random.randint(10, 100, 30),
+                'total_items': np.random.randint(20, 200, 30),
+                'total_revenue': np.round(np.random.uniform(1000, 50000, 30), 2),
+                'total_freight': np.round(np.random.uniform(200, 5000, 30), 2),
+                'avg_price': np.round(np.random.uniform(50, 200, 30), 2),
+                'avg_order_value': np.round(np.random.uniform(100, 500, 30), 2),
+            })
+        
+        output_path = f'{self.output_dir}/agg_daily_revenue.parquet'
+        daily.to_parquet(output_path, index=False)
+        print(f"    agg_daily_revenue: {len(daily):,} rows")
+        
+        return daily
+    
+    def create_customer_rfm(self, silver_orders: pd.DataFrame,
+                            silver_items: pd.DataFrame) -> pd.DataFrame:
+        """Tạo bảng RFM (Recency, Frequency, Monetary) cho phân khúc khách hàng."""
+        print(f"  [GOLD] Creating customer_rfm_segments...")
+        
+        if 'order_purchase_timestamp' not in silver_orders.columns:
+            print("    [SKIP] No timestamp column for RFM")
+            return pd.DataFrame()
+        
+        # Merge
+        merged = silver_items.merge(
+            silver_orders[['order_id', 'customer_id', 'order_purchase_timestamp']],
+            on='order_id', how='inner'
+        )
+        merged['order_purchase_timestamp'] = pd.to_datetime(
+            merged['order_purchase_timestamp']
+        )
+        
+        # Reference date
+        reference_date = merged['order_purchase_timestamp'].max() + pd.Timedelta(days=1)
+        
+        # RFM calculation
+        rfm = merged.groupby('customer_id').agg(
+            recency_days=('order_purchase_timestamp', 
+                         lambda x: (reference_date - x.max()).days),
+            frequency=('order_id', 'nunique'),
+            monetary=('price', 'sum'),
+        ).reset_index()
+        
+        # RFM scoring (quintiles)
+        rfm['r_score'] = pd.qcut(rfm['recency_days'], q=5, labels=[5,4,3,2,1]).astype(int)
+        rfm['f_score'] = pd.qcut(rfm['frequency'].rank(method='first'), q=5, labels=[1,2,3,4,5]).astype(int)
+        rfm['m_score'] = pd.qcut(rfm['monetary'].rank(method='first'), q=5, labels=[1,2,3,4,5]).astype(int)
+        
+        rfm['rfm_score'] = rfm['r_score'] * 100 + rfm['f_score'] * 10 + rfm['m_score']
+        
+        # Segment naming
+        def segment_name(row):
+            r, f, m = row['r_score'], row['f_score'], row['m_score']
+            if r >= 4 and f >= 4:
+                return 'Champions'
+            elif r >= 3 and f >= 3:
+                return 'Loyal Customers'
+            elif r >= 4 and f <= 2:
+                return 'New Customers'
+            elif r <= 2 and f >= 3:
+                return 'At Risk'
+            elif r <= 2 and f <= 2:
+                return 'Lost'
+            else:
+                return 'Regular'
+        
+        rfm['rfm_segment'] = rfm.apply(segment_name, axis=1)
+        rfm = rfm.round(2)
+        
+        output_path = f'{self.output_dir}/customer_rfm_segments.parquet'
+        rfm.to_parquet(output_path, index=False)
+        
+        print(f"    customer_rfm: {len(rfm):,} customers")
+        print(f"    Segments: {rfm['rfm_segment'].value_counts().to_dict()}")
+        
+        return rfm
+    
+    def build_all(self, silver_tables: dict) -> dict:
+        """Build tất cả Gold layer tables."""
+        print("\n" + "=" * 60)
+        print("  GOLD LAYER - Business-Ready Data")
+        print("=" * 60)
+        
+        gold = {}
+        
+        orders = silver_tables.get('orders', pd.DataFrame())
+        items = silver_tables.get('order_items', pd.DataFrame())
+        
+        gold['dim_time'] = self.create_dim_time(orders)
+        gold['agg_daily_revenue'] = self.create_agg_daily_revenue(orders, items)
+        gold['customer_rfm'] = self.create_customer_rfm(orders, items)
+        
+        return gold
+
+
+# ==============================================================================
+# MAIN: Orchestrate Bronze → Silver → Gold
+# ==============================================================================
+
+if __name__ == '__main__':
+    print("=" * 70)
+    print("  MEDALLION ARCHITECTURE: Bronze → Silver → Gold")
+    print("  BIM5021 - Lab 2b")
+    print("  Dataset: Olist Brazilian E-commerce")
+    print("=" * 70)
+    
+    # Bronze
+    bronze = BronzeLayer(DATA_DIR, OUTPUT_DIR)
+    bronze_tables = bronze.ingest_all()
+    
+    # Silver
+    silver = SilverLayer(OUTPUT_DIR)
+    silver_tables = silver.process_all(bronze_tables)
+    
+    # Gold
+    gold = GoldLayer(OUTPUT_DIR)
+    gold_tables = gold.build_all(silver_tables)
+    
+    # Summary
+    print("\n" + "=" * 70)
+    print("  PIPELINE SUMMARY")
+    print("=" * 70)
+    
+    for layer_name, tables in [('Bronze', bronze_tables), ('Silver', silver_tables), ('Gold', gold_tables)]:
+        total_rows = sum(len(df) for df in tables.values() if isinstance(df, pd.DataFrame))
+        print(f"\n  {layer_name}: {len(tables)} tables, {total_rows:,} total rows")
+        for name, df in tables.items():
+            if isinstance(df, pd.DataFrame):
+                print(f"    - {name}: {len(df):,} rows x {len(df.columns)} columns")
+    
+    print("\n" + "=" * 70)
+    print("  HOAN THANH! Check output in: " + OUTPUT_DIR)
+    print("=" * 70)