AutoViz Automatic EDA Skill

Master AutoViz for instant exploratory data analysis with a single line of code. Generate comprehensive visualizations, detect patterns, identify outliers, and export publication-ready charts automatically.

When to Use This Skill

USE AutoViz when:

• Quick EDA - Need rapid insights into a new dataset
• Initial exploration - Starting analysis on unfamiliar data
• Pattern discovery - Automatically detect relationships between variables
• Presentation prep - Need charts quickly for stakeholder meetings
• Large datasets - Built-in sampling handles big data efficiently
• Feature analysis - Understanding distribution and importance of features
• Correlation hunting - Finding relationships without manual chart creation
• Report generation - Export comprehensive HTML reports

DON'T USE AutoViz when:

• Custom visualizations - Need highly specific chart designs
• Interactive dashboards - Use Streamlit or Dash instead
• Real-time data - Streaming visualization requirements
• Production systems - Charts for automated pipelines (use Plotly/Altair)
• Precise statistical tests - Need formal hypothesis testing
• Domain-specific plots - Specialized visualizations not in standard EDA

Prerequisites

# Basic installation
pip install autoviz

# With all visualization backends
pip install autoviz matplotlib seaborn plotly bokeh

# Using uv (recommended)
uv pip install autoviz pandas matplotlib seaborn plotly

# Jupyter notebook support
pip install autoviz ipywidgets notebook

# Verify installation
python -c "from autoviz import AutoViz_Class; print('AutoViz ready!')"

Core Capabilities

1. Basic One-Line EDA

Simplest Usage:

from autoviz import AutoViz_Class

# Initialize AutoViz
AV = AutoViz_Class()

# Automatic visualization with one line
# Returns a dataframe and generates all charts
df_analyzed = AV.AutoViz(
    filename="data.csv",
    sep=",",
    depVar="",  # Target variable (optional)
    dfte=None,  # Pass DataFrame directly instead of filename
    header=0,
    verbose=1,  # 0=minimal, 1=medium, 2=detailed output
    lowess=False,
    chart_format="svg",
    max_rows_analyzed=150000,
    max_cols_analyzed=30
)

print(f"Analyzed {df_analyzed.shape[0]} rows, {df_analyzed.shape[1]} columns")

From DataFrame:

from autoviz import AutoViz_Class
import pandas as pd

# Load your data
df = pd.read_csv("sales_data.csv")

# Or create sample data
df = pd.DataFrame({
    "revenue": [100, 200, 150, 300, 250, 400, 350, 500],
    "units": [10, 20, 15, 30, 25, 40, 35, 50],
    "category": ["A", "B", "A", "B", "A", "B", "A", "B"],
    "region": ["North", "South", "East", "West", "North", "South", "East", "West"],
    "profit": [20, 40, 30, 60, 50, 80, 70, 100],
    "customer_age": [25, 35, 45, 55, 30, 40, 50, 60]
})

# Initialize and visualize
AV = AutoViz_Class()

# Pass DataFrame directly using dfte parameter
df_result = AV.AutoViz(
    filename="",  # Empty when using dfte
    sep=",",
    depVar="profit",  # Optional: specify target variable
    dfte=df,
    header=0,
    verbose=1,
    chart_format="png"
)

With Target Variable Analysis:

from autoviz import AutoViz_Class
import pandas as pd

# Classification dataset
df_classification = pd.DataFrame({
    "feature_1": [1.2, 2.3, 1.5, 3.4, 2.1, 4.5, 3.2, 5.1],
    "feature_2": [0.5, 1.2, 0.8, 2.1, 1.0, 3.2, 2.4, 4.0],
    "feature_3": ["low", "medium", "low", "high", "medium", "high", "medium", "high"],
    "target": [0, 0, 0, 1, 0, 1, 1, 1]
})

AV = AutoViz_Class()

# Specify target variable for focused analysis
df_analyzed = AV.AutoViz(
    filename="",
    sep=",",
    depVar="target",  # Target variable for classification
    dfte=df_classification,
    header=0,
    verbose=2,  # More detailed output
    chart_format="svg"
)

# Regression dataset
df_regression = pd.DataFrame({
    "size": [1000, 1500, 1200, 2000, 1800, 2500, 2200, 3000],
    "bedrooms": [2, 3, 2, 4, 3, 4, 4, 5],
    "location": ["urban", "suburban", "urban", "rural", "suburban", "rural", "suburban", "rural"],
    "age": [5, 10, 3, 15, 8, 20, 12, 25],
    "price": [200000, 280000, 220000, 350000, 300000, 380000, 340000, 420000]
})

# Analyze with continuous target
df_analyzed = AV.AutoViz(
    filename="",
    sep=",",
    depVar="price",  # Continuous target
    dfte=df_regression,
    header=0,
    verbose=1,
    chart_format="png"
)

2. Chart Format and Output Options

Different Chart Formats:

from autoviz import AutoViz_Class
import pandas as pd

df = pd.read_csv("data.csv")
AV = AutoViz_Class()

# SVG format (vector, scalable)
df_svg = AV.AutoViz(
    filename="",
    dfte=df,
    chart_format="svg",  # Scalable vector graphics
    verbose=1
)

# PNG format (raster, good for presentations)
df_png = AV.AutoViz(
    filename="",
    dfte=df,
    chart_format="png",  # PNG images
    verbose=1
)

# HTML format (interactive, for web)
df_html = AV.AutoViz(
    filename="",
    dfte=df,
    chart_format="html",  # Interactive HTML
    verbose=1
)

# Bokeh backend for interactive plots
df_bokeh = AV.AutoViz(
    filename="",
    dfte=df,
    chart_format="bokeh",  # Bokeh interactive
    verbose=1
)

# Server mode (for Jupyter notebooks)
df_server = AV.AutoViz(
    filename="",
    dfte=df,
    chart_format="server",  # Inline in notebook
    verbose=1
)

Saving Charts to Directory:

from autoviz import AutoViz_Class
import pandas as pd
import os

# Create output directory
output_dir = "analysis_output"
os.makedirs(output_dir, exist_ok=True)

df = pd.read_csv("data.csv")
AV = AutoViz_Class()

# Save all charts to specified directory
df_analyzed = AV.AutoViz(
    filename="",
    dfte=df,
    chart_format="png",
    save_plot_dir=output_dir,  # Directory to save plots
    verbose=1
)

# List generated files
for file in os.listdir(output_dir):
    print(f"Generated: {file}")

3. Handling Large Datasets

Sampling Strategies:

from autoviz import AutoViz_Class
import pandas as pd
import numpy as np

# Create large dataset
np.random.seed(42)
large_df = pd.DataFrame({
    "feature_" + str(i): np.random.randn(500000)
    for i in range(20)
})
large_df["category"] = np.random.choice(["A", "B", "C", "D"], 500000)
large_df["target"] = np.random.randint(0, 2, 500000)

print(f"Dataset size: {large_df.shape}")

AV = AutoViz_Class()

# Control sampling with max_rows_analyzed
df_analyzed = AV.AutoViz(
    filename="",
    dfte=large_df,
    max_rows_analyzed=100000,  # Sample 100K rows
    max_cols_analyzed=25,  # Limit columns analyzed
    verbose=1,
    chart_format="png"
)

# For very large datasets, use smaller sample
df_analyzed_small = AV.AutoViz(
    filename="",
    dfte=large_df,
    max_rows_analyzed=50000,  # Smaller sample for speed
    max_cols_analyzed=15,
    verbose=0,  # Minimal output
    chart_format="svg"
)

Memory-Efficient Analysis:

from autoviz import AutoViz_Class
import pandas as pd

def analyze_large_file(file_path: str, sample_size: int = 100000) -> pd.DataFrame:
    """
    Analyze large files efficiently with sampling.

    Args:
        file_path: Path to CSV file
        sample_size: Number of rows to sample

    Returns:
        Analyzed DataFrame
    """
    # Read only a sample for initial analysis
    total_rows = sum(1 for _ in open(file_path)) - 1  # Exclude header

    if total_rows > sample_size:
        # Calculate skip probability
        skip_prob = 1 - (sample_size / total_rows)

        # Read with sampling
        df = pd.read_csv(
            file_path,
            skiprows=lambda i: i > 0 and np.random.random() < skip_prob
        )
    else:
        df = pd.read_csv(file_path)

    print(f"Sampled {len(df)} rows from {total_rows} total")

    AV = AutoViz_Class()
    return AV.AutoViz(
        filename="",
        dfte=df,
        verbose=1,
        chart_format="png"
    )

# Usage
# df_result = analyze_large_file("huge_dataset.csv", sample_size=75000)

4. Feature Analysis and Distribution Plots

Understanding Feature Distributions:

from autoviz import AutoViz_Class
import pandas as pd
import numpy as np

# Create dataset with various distributions
np.random.seed(42)
df = pd.DataFrame({
    # Normal distribution
    "normal": np.random.normal(100, 15, 1000),

    # Skewed distribution
    "skewed": np.random.exponential(50, 1000),

    # Bimodal distribution
    "bimodal": np.concatenate([
        np.random.normal(30, 5, 500),
        np.random.normal(70, 5, 500)
    ]),

    # Uniform distribution
    "uniform": np.random.uniform(0, 100, 1000),

    # Categorical with different frequencies
    "category_balanced": np.random.choice(["A", "B", "C"], 1000),
    "category_imbalanced": np.random.choice(
        ["Common", "Rare", "Very Rare"],
        1000,
        p=[0.8, 0.15, 0.05]
    ),

    # Target variable
    "target": np.random.choice([0, 1], 1000, p=[0.7, 0.3])
})

AV = AutoViz_Class()

# AutoViz will automatically:
# 1. Detect distribution types
# 2. Create appropriate histograms
# 3. Show box plots for numerical features
# 4. Create bar charts for categorical features
# 5. Highlight potential outliers

df_analyzed = AV.AutoViz(
    filename="",
    dfte=df,
    depVar="target",
    verbose=2,
    chart_format="svg"
)

Categorical Feature Analysis:

from autoviz import AutoViz_Class
import pandas as pd
import numpy as np

# Dataset with multiple categorical features
df = pd.DataFrame({
    "product_category": np.random.choice(
        ["Electronics", "Clothing", "Food", "Home", "Sports"],
        1000
    ),
    "customer_segment": np.random.choice(
        ["Premium", "Standard", "Budget"],
        1000,
        p=[0.2, 0.5, 0.3]
    ),
    "region": np.random.choice(
        ["North", "South", "East", "West"],
        1000
    ),
    "channel": np.random.choice(
        ["Online", "Store", "Mobile"],
        1000
    ),
    "revenue": np.random.exponential(500, 1000),
    "quantity": np.random.randint(1, 20, 1000)
})

AV = AutoViz_Class()

# AutoViz creates:
# - Bar charts for each categorical variable
# - Cross-tabulation visualizations
# - Category vs numerical variable plots

df_analyzed = AV.AutoViz(
    filename="",
    dfte=df,
    depVar="revenue",
    verbose=1,
    chart_format="png"
)

5. Correlation Detection

Automatic Correlation Analysis:

from autoviz import AutoViz_Class
import pandas as pd
import numpy as np

# Create dataset with known correlations
np.random.seed(42)
n = 1000

# Base variables
x1 = np.random.randn(n)
x2 = np.random.randn(n)

df = pd.DataFrame({
    "x1": x1,
    "x2": x2,
    # Strongly correlated with x1
    "y1": x1 * 2 + np.random.randn(n) * 0.5,
    # Moderately correlated with x2
    "y2": x2 + np.random.randn(n) * 1.5,
    # Negatively correlated
    "y3": -x1 + np.random.randn(n) * 0.8,
    # No correlation
    "y4": np.random.randn(n),
    # Non-linear relationship
    "y5": x1 ** 2 + np.random.randn(n) * 0.5,
    # Target
    "target": (x1 + x2 > 0).astype(int)
})

AV = AutoViz_Class()

# AutoViz generates:
# 1. Correlation heatmap
# 2. Scatter plots for highly correlated pairs
# 3. Pair plots for feature relationships

df_analyzed = AV.AutoViz(
    filename="",
    dfte=df,
    depVar="target",
    verbose=2,
    chart_format="svg"
)

Correlation with Lowess Smoothing:

from autoviz import AutoViz_Class
import pandas as pd
import numpy as np

# Dataset with non-linear relationships
np.random.seed(42)
x = np.linspace(0, 10, 500)

df = pd.DataFrame({
    "x": x,
    "linear": 2 * x + np.random.randn(500) * 2,
    "quadratic": x ** 2 + np.random.randn(500) * 5,
    "sinusoidal": 10 * np.sin(x) + np.random.randn(500) * 2,
    "logarithmic": 5 * np.log(x + 1) + np.random.randn(500),
    "target": x + np.random.randn(500)
})

AV = AutoViz_Class()

# Enable lowess smoothing to see trends
df_analyzed = AV.AutoViz(
    filename="",
    dfte=df,
    depVar="target",
    lowess=True,  # Enable lowess smoothing
    verbose=1,
    chart_format="png"
)

6. Outlier Detection and Highlighting

Automatic Outlier Identification:

from autoviz import AutoViz_Class
import pandas as pd
import numpy as np

# Create dataset with outliers
np.random.seed(42)
n = 1000

# Normal data with injected outliers
revenue = np.concatenate([
    np.random.normal(1000, 200, n - 20),  # Normal values
    np.random.uniform(3000, 5000, 10),    # High outliers
    np.random.uniform(-500, 0, 10)        # Low outliers
])

units = np.concatenate([
    np.random.normal(50, 10, n - 15),
    np.random.uniform(150, 200, 15)       # Outliers
])

df = pd.DataFrame({
    "revenue": revenue,
    "units": units,
    "cost": np.abs(revenue * 0.6 + np.random.randn(n) * 100),
    "category": np.random.choice(["A", "B", "C"], n),
    "region": np.random.choice(["North", "South", "East", "West"], n)
})

AV = AutoViz_Class()

# AutoViz automatically:
# 1. Detects outliers using IQR method
# 2. Highlights them in box plots
# 3. Shows them in scatter plots
# 4. Reports outlier counts

df_analyzed = AV.AutoViz(
    filename="",
    dfte=df,
    verbose=2,
    chart_format="svg"
)

Custom Outlier Analysis Wrapper:

from autoviz import AutoViz_Class
import pandas as pd
import numpy as np

def analyze_with_outlier_report(df: pd.DataFrame, target: str = "") -> dict:
    """
    Run AutoViz and provide detailed outlier report.

    Args:
        df: Input DataFrame
        target: Target variable name (optional)

    Returns:
        Dictionary with analysis results and outlier info
    """
    # Calculate outliers before visualization
    outlier_info = {}
    numeric_cols = df.select_dtypes(include=[np.number]).columns

    for col in numeric_cols:
        Q1 = df[col].quantile(0.25)
        Q3 = df[col].quantile(0.75)
        IQR = Q3 - Q1

        lower_bound = Q1 - 1.5 * IQR
        upper_bound = Q3 + 1.5 * IQR

        outliers = df[(df[col] < lower_bound) | (df[col] > upper_bound)]

        outlier_info[col] = {
            "count": len(outliers),
            "percentage": len(outliers) / len(df) * 100,
            "lower_bound": lower_bound,
            "upper_bound": upper_bound,
            "min_outlier": outliers[col].min() if len(outliers) > 0 else None,
            "max_outlier": outliers[col].max() if len(outliers) > 0 else None
        }

    # Run AutoViz
    AV = AutoViz_Class()
    df_analyzed = AV.AutoViz(
        filename="",
        dfte=df,
        depVar=target,
        verbose=1,
        chart_format="png"
    )

    return {
        "analyzed_df": df_analyzed,
        "outlier_report": outlier_info,
        "total_outliers": sum(info["count"] for info in outlier_info.values())
    }

# Usage
# result = analyze_with_outlier_report(df, target="revenue")
# print(f"Total outliers found: {result['total_outliers']}")

7. Export to HTML and Notebooks

HTML Report Generation:

from autoviz import AutoViz_Class
import pandas as pd
import os

def generate_html_report(
    df: pd.DataFrame,
    output_dir: str,
    report_name: str = "eda_report",
    target: str = ""
) -> str:
    """
    Generate comprehensive HTML report with AutoViz.

    Args:
        df: Input DataFrame
        output_dir: Directory for output files
        report_name: Name for the report
        target: Target variable (optional)

    Returns:
        Path to generated report
    """
    os.makedirs(output_dir, exist_ok=True)

    AV = AutoViz_Class()

    # Generate HTML charts
    df_analyzed = AV.AutoViz(
        filename="",
        dfte=df,
        depVar=target,
        chart_format="html",
        save_plot_dir=output_dir,
        verbose=1
    )

    # Create summary HTML
    html_content = f"""
    <!DOCTYPE html>
    <html>
    <head>
        <title>{report_name} - AutoViz EDA Report</title>
        <style>
            body {{ font-family: Arial, sans-serif; margin: 20px; }}
            h1 {{ color: #333; }}
            .summary {{ background: #f5f5f5; padding: 15px; border-radius: 5px; }}
            .chart-container {{ margin: 20px 0; }}
        </style>
    </head>
    <body>
        <h1>{report_name}</h1>

        <div class="summary">
            <h2>Dataset Summary</h2>
            <p>Rows: {len(df):,}</p>
            <p>Columns: {len(df.columns)}</p>
            <p>Numeric columns: {len(df.select_dtypes(include=['number']).columns)}</p>
            <p>Categorical columns: {len(df.select_dtypes(include=['object', 'category']).columns)}</p>
            <p>Target variable: {target if target else 'Not specified'}</p>
        </div>

        <h2>Column Information</h2>
        <table border="1" style="border-collapse: collapse;">
            <tr><th>Column</th><th>Type</th><th>Non-Null</th><th>Unique</th></tr>
    """

    for col in df.columns:
        html_content += f"""
            <tr>
                <td>{col}</td>
                <td>{df[col].dtype}</td>
                <td>{df[col].notna().sum()}</td>
                <td>{df[col].nunique()}</td>
            </tr>
        """

    html_content += """
        </table>

        <h2>Generated Charts</h2>
        <p>Charts have been saved to the output directory.</p>
    </body>
    </html>
    """

    report_path = os.path.join(output_dir, f"{report_name}.html")
    with open(report_path, "w") as f:
        f.write(html_content)

    return report_path

# Usage
# report_path = generate_html_report(df, "output/eda", "sales_analysis", "revenue")
# print(f"Report saved to: {report_path}")

Jupyter Notebook Integration:

# In Jupyter Notebook
from autoviz import AutoViz_Class
import pandas as pd

# Load data
df = pd.read_csv("data.csv")

# Initialize AutoViz
AV = AutoViz_Class()

# Use 'server' format for inline display in notebooks
%matplotlib inline

df_analyzed = AV.AutoViz(
    filename="",
    dfte=df,
    depVar="target",
    chart_format="server",  # Display inline in notebook
    verbose=1
)

# Alternative: Use bokeh for interactive plots in notebooks
df_analyzed = AV.AutoViz(
    filename="",
    dfte=df,
    depVar="target",
    chart_format="bokeh",  # Interactive Bokeh plots
    verbose=1
)

Export to Notebook File:

from autoviz import AutoViz_Class
import pandas as pd
import nbformat as nbf
import os

def create_eda_notebook(
    df: pd.DataFrame,
    output_path: str,
    dataset_name: str = "dataset"
) -> str:
    """
    Create a Jupyter notebook with AutoViz EDA.

    Args:
        df: Input DataFrame
        output_path: Path for output notebook
        dataset_name: Name for the dataset

    Returns:
        Path to created notebook
    """
    nb = nbf.v4.new_notebook()

    cells = [
        nbf.v4.new_markdown_cell(f"# Exploratory Data Analysis: {dataset_name}"),

        nbf.v4.new_code_cell("""
from autoviz import AutoViz_Class
import pandas as pd
import warnings
warnings.filterwarnings('ignore')
"""),

        nbf.v4.new_markdown_cell("## Load Data"),

        nbf.v4.new_code_cell(f"""
# Data is pre-loaded
df = pd.read_csv("{dataset_name}.csv")  # Update path as needed
print(f"Dataset shape: {{df.shape}}")
df.head()
"""),

        nbf.v4.new_markdown_cell("## AutoViz Analysis"),

        nbf.v4.new_code_cell("""
AV = AutoViz_Class()

df_analyzed = AV.AutoViz(
    filename="",
    dfte=df,
    chart_format="server",
    verbose=1
)
"""),

        nbf.v4.new_markdown_cell("## Summary Statistics"),

        nbf.v4.new_code_cell("""
df.describe()
"""),

        nbf.v4.new_markdown_cell("## Missing Values"),

        nbf.v4.new_code_cell("""
missing = df.isnull().sum()
missing[missing > 0].sort_values(ascending=False)
""")
    ]

    nb.cells = cells

    with open(output_path, "w") as f:
        nbf.write(nb, f)

    return output_path

# Usage
# notebook_path = create_eda_notebook(df, "eda_analysis.ipynb", "sales_data")

Complete Examples

Example 1: Sales Data EDA Pipeline

from autoviz import AutoViz_Class
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
import os

def sales_eda_pipeline(
    data_path: str,
    output_dir: str,
    target_column: str = "revenue"
) -> dict:
    """
    Complete EDA pipeline for sales data using AutoViz.

    Args:
        data_path: Path to sales data CSV
        output_dir: Directory for output files
        target_column: Target variable for analysis

    Returns:
        Dictionary with analysis results
    """
    os.makedirs(output_dir, exist_ok=True)

    # Load data
    print("Loading data...")
    df = pd.read_csv(data_path)

    # Basic data info
    print(f"Dataset shape: {df.shape}")
    print(f"Columns: {list(df.columns)}")

    # Data type summary
    dtype_summary = df.dtypes.value_counts()
    print(f"\nData types:\n{dtype_summary}")

    # Missing values
    missing = df.isnull().sum()
    missing_pct = (missing / len(df) * 100).round(2)
    missing_df = pd.DataFrame({
        "missing_count": missing,
        "missing_pct": missing_pct
    })
    missing_df = missing_df[missing_df["missing_count"] > 0]

    if len(missing_df) > 0:
        print(f"\nMissing values:\n{missing_df}")
    else:
        print("\nNo missing values found")

    # Run AutoViz
    print("\nRunning AutoViz analysis...")
    AV = AutoViz_Class()

    df_analyzed = AV.AutoViz(
        filename="",
        dfte=df,
        depVar=target_column if target_column in df.columns else "",
        chart_format="png",
        save_plot_dir=output_dir,
        max_rows_analyzed=100000,
        verbose=1
    )

    # Calculate additional statistics
    numeric_cols = df.select_dtypes(include=[np.number]).columns

    stats = {
        "shape": df.shape,
        "memory_mb": df.memory_usage(deep=True).sum() / 1024**2,
        "missing_values": missing.sum(),
        "numeric_columns": len(numeric_cols),
        "categorical_columns": len(df.columns) - len(numeric_cols)
    }

    if target_column in df.columns:
        target_stats = df[target_column].describe().to_dict()
        stats["target_stats"] = target_stats

    # Save summary
    summary_path = os.path.join(output_dir, "eda_summary.txt")
    with open(summary_path, "w") as f:
        f.write(f"EDA Summary - {datetime.now()}\n")
        f.write("=" * 50 + "\n\n")
        f.write(f"Dataset: {data_path}\n")
        f.write(f"Shape: {df.shape}\n")
        f.write(f"Memory: {stats['memory_mb']:.2f} MB\n\n")
        f.write("Columns:\n")
        for col in df.columns:
            f.write(f"  - {col}: {df[col].dtype}\n")

    print(f"\nAnalysis complete! Results saved to: {output_dir}")

    return {
        "dataframe": df_analyzed,
        "statistics": stats,
        "output_dir": output_dir
    }

# Generate sample data for testing
def generate_sample_sales_data(n_rows: int = 10000) -> pd.DataFrame:
    """Generate sample sales data for testing."""
    np.random.seed(42)

    dates = pd.date_range(
        start="2024-01-01",
        end="2025-12-31",
        periods=n_rows
    )

    return pd.DataFrame({
        "date": dates,
        "product_id": np.random.randint(1000, 9999, n_rows),
        "category": np.random.choice(
            ["Electronics", "Clothing", "Food", "Home", "Sports"],
            n_rows
        ),
        "region": np.random.choice(
            ["North", "South", "East", "West"],
            n_rows
        ),
        "revenue": np.random.exponential(500, n_rows),
        "units": np.random.randint(1, 50, n_rows),
        "cost": np.random.exponential(300, n_rows),
        "customer_age": np.random.normal(40, 15, n_rows).astype(int),
        "is_promotion": np.random.choice([0, 1], n_rows, p=[0.7, 0.3])
    })

# Usage
# sample_df = generate_sample_sales_data(10000)
# sample_df.to_csv("sample_sales.csv", index=False)
# results = sales_eda_pipeline("sample_sales.csv", "sales_eda_output", "revenue")

Example 2: Machine Learning Feature Analysis

from autoviz import AutoViz_Class
import pandas as pd
import numpy as np
from sklearn.datasets import make_classification, make_regression
import os

def ml_feature_analysis(
    X: pd.DataFrame,
    y: pd.Series,
    task_type: str = "classification",
    output_dir: str = "ml_eda"
) -> dict:
    """
    Analyze features for machine learning using AutoViz.

    Args:
        X: Feature DataFrame
        y: Target Series
        task_type: 'classification' or 'regression'
        output_dir: Output directory

    Returns:
        Analysis results dictionary
    """
    os.makedirs(output_dir, exist_ok=True)

    # Combine features and target
    df = X.copy()
    df["target"] = y

    print(f"Feature Analysis for {task_type}")
    print(f"Features: {len(X.columns)}")
    print(f"Samples: {len(X)}")

    # Feature statistics
    feature_stats = []
    for col in X.columns:
        stats = {
            "feature": col,
            "dtype": str(X[col].dtype),
            "missing": X[col].isnull().sum(),
            "unique": X[col].nunique(),
            "mean": X[col].mean() if np.issubdtype(X[col].dtype, np.number) else None,
            "std": X[col].std() if np.issubdtype(X[col].dtype, np.number) else None
        }
        feature_stats.append(stats)

    feature_stats_df = pd.DataFrame(feature_stats)

    # Run AutoViz
    AV = AutoViz_Class()

    df_analyzed = AV.AutoViz(
        filename="",
        dfte=df,
        depVar="target",
        chart_format="png",
        save_plot_dir=output_dir,
        verbose=2
    )

    # Calculate feature correlations with target
    numeric_cols = X.select_dtypes(include=[np.number]).columns
    correlations = {}

    for col in numeric_cols:
        corr = df[col].corr(df["target"])
        correlations[col] = corr

    corr_df = pd.DataFrame.from_dict(
        correlations, orient="index", columns=["correlation"]
    ).sort_values("correlation", key=abs, ascending=False)

    # Save feature importance summary
    corr_df.to_csv(os.path.join(output_dir, "feature_correlations.csv"))
    feature_stats_df.to_csv(os.path.join(output_dir, "feature_statistics.csv"))

    print(f"\nTop correlated features:")
    print(corr_df.head(10))

    return {
        "analyzed_df": df_analyzed,
        "feature_stats": feature_stats_df,
        "correlations": corr_df,
        "output_dir": output_dir
    }

# Generate classification dataset
def create_classification_dataset(n_samples: int = 5000) -> tuple:
    """Create sample classification dataset."""
    X, y = make_classification(
        n_samples=n_samples,
        n_features=15,
        n_informative=8,
        n_redundant=3,
        n_classes=2,
        random_state=42
    )

    feature_names = [f"feature_{i}" for i in range(X.shape[1])]
    X_df = pd.DataFrame(X, columns=feature_names)

    # Add categorical features
    X_df["category_1"] = np.random.choice(["A", "B", "C"], n_samples)
    X_df["category_2"] = np.random.choice(["Low", "Medium", "High"], n_samples)

    y_series = pd.Series(y, name="target")

    return X_df, y_series

# Generate regression dataset
def create_regression_dataset(n_samples: int = 5000) -> tuple:
    """Create sample regression dataset."""
    X, y = make_regression(
        n_samples=n_samples,
        n_features=12,
        n_informative=6,
        noise=10,
        random_state=42
    )

    feature_names = [f"feature_{i}" for i in range(X.shape[1])]
    X_df = pd.DataFrame(X, columns=feature_names)

    # Add categorical features
    X_df["region"] = np.random.choice(["North", "South", "East", "West"], n_samples)
    X_df["segment"] = np.random.choice(["Premium", "Standard", "Budget"], n_samples)

    y_series = pd.Series(y, name="target")

    return X_df, y_series

# Usage
# X, y = create_classification_dataset(5000)
# results = ml_feature_analysis(X, y, "classification", "classification_eda")

# X, y = create_regression_dataset(5000)
# results = ml_feature_analysis(X, y, "regression", "regression_eda")

Example 3: Multi-Dataset Comparison

from autoviz import AutoViz_Class
import pandas as pd
import numpy as np
import os
from datetime import datetime

def compare_datasets(
    datasets: dict,
    output_dir: str = "comparison_output"
) -> dict:
    """
    Compare multiple datasets using AutoViz.

    Args:
        datasets: Dictionary of {name: DataFrame}
        output_dir: Output directory

    Returns:
        Comparison results
    """
    os.makedirs(output_dir, exist_ok=True)

    comparison_results = {}
    AV = AutoViz_Class()

    for name, df in datasets.items():
        print(f"\n{'='*50}")
        print(f"Analyzing: {name}")
        print(f"{'='*50}")

        # Create dataset-specific output directory
        dataset_dir = os.path.join(output_dir, name.replace(" ", "_"))
        os.makedirs(dataset_dir, exist_ok=True)

        # Run AutoViz
        df_analyzed = AV.AutoViz(
            filename="",
            dfte=df,
            chart_format="png",
            save_plot_dir=dataset_dir,
            verbose=1
        )

        # Collect statistics
        numeric_cols = df.select_dtypes(include=[np.number]).columns

        stats = {
            "rows": len(df),
            "columns": len(df.columns),
            "numeric_columns": len(numeric_cols),
            "categorical_columns": len(df.columns) - len(numeric_cols),
            "missing_values": df.isnull().sum().sum(),
            "memory_mb": df.memory_usage(deep=True).sum() / 1024**2
        }

        # Numeric column statistics
        if len(numeric_cols) > 0:
            stats["numeric_summary"] = df[numeric_cols].describe().to_dict()

        comparison_results[name] = {
            "stats": stats,
            "output_dir": dataset_dir
        }

    # Create comparison summary
    summary_data = []
    for name, result in comparison_results.items():
        row = {"dataset": name}
        row.update(result["stats"])
        summary_data.append(row)

    summary_df = pd.DataFrame(summary_data)
    summary_path = os.path.join(output_dir, "comparison_summary.csv")
    summary_df.to_csv(summary_path, index=False)

    print(f"\n{'='*50}")
    print("Comparison Summary")
    print(f"{'='*50}")
    print(summary_df[["dataset", "rows", "columns", "missing_values", "memory_mb"]])

    return {
        "results": comparison_results,
        "summary": summary_df,
        "output_dir": output_dir
    }

# Create sample datasets for comparison
def create_comparison_datasets() -> dict:
    """Create multiple datasets for comparison."""
    np.random.seed(42)

    # Dataset 1: Sales Q1
    df_q1 = pd.DataFrame({
        "revenue": np.random.exponential(1000, 5000),
        "units": np.random.randint(1, 100, 5000),
        "category": np.random.choice(["A", "B", "C"], 5000),
        "region": np.random.choice(["North", "South"], 5000),
        "month": np.random.choice(["Jan", "Feb", "Mar"], 5000)
    })

    # Dataset 2: Sales Q2 (different distribution)
    df_q2 = pd.DataFrame({
        "revenue": np.random.exponential(1200, 6000),  # Higher revenue
        "units": np.random.randint(5, 120, 6000),      # More units
        "category": np.random.choice(["A", "B", "C", "D"], 6000),  # New category
        "region": np.random.choice(["North", "South", "East"], 6000),
        "month": np.random.choice(["Apr", "May", "Jun"], 6000)
    })

    # Dataset 3: Customer data
    df_customers = pd.DataFrame({
        "age": np.random.normal(40, 15, 3000).astype(int),
        "income": np.random.exponential(50000, 3000),
        "tenure_months": np.random.randint(1, 120, 3000),
        "segment": np.random.choice(["Premium", "Standard", "Budget"], 3000),
        "is_active": np.random.choice([0, 1], 3000, p=[0.2, 0.8])
    })

    return {
        "Sales Q1": df_q1,
        "Sales Q2": df_q2,
        "Customer Data": df_customers
    }

# Usage
# datasets = create_comparison_datasets()
# comparison = compare_datasets(datasets, "multi_dataset_comparison")

Integration Examples

AutoViz with Streamlit

import streamlit as st
from autoviz import AutoViz_Class
import pandas as pd
import os
import tempfile

st.set_page_config(page_title="AutoViz EDA Tool", layout="wide")

st.title("AutoViz Exploratory Data Analysis")

# File upload
uploaded_file = st.file_uploader("Upload CSV file", type=["csv"])

if uploaded_file is not None:
    df = pd.read_csv(uploaded_file)

    st.subheader("Data Preview")
    st.dataframe(df.head(100))

    col1, col2 = st.columns(2)
    with col1:
        st.metric("Rows", f"{len(df):,}")
    with col2:
        st.metric("Columns", len(df.columns))

    # Target variable selection
    target = st.selectbox(
        "Select target variable (optional)",
        ["None"] + list(df.columns)
    )

    if st.button("Run AutoViz Analysis"):
        with st.spinner("Generating visualizations..."):
            # Create temp directory for outputs
            with tempfile.TemporaryDirectory() as tmpdir:
                AV = AutoViz_Class()

                df_analyzed = AV.AutoViz(
                    filename="",
                    dfte=df,
                    depVar="" if target == "None" else target,
                    chart_format="png",
                    save_plot_dir=tmpdir,
                    verbose=0
                )

                # Display generated charts
                st.subheader("Generated Visualizations")

                for file in os.listdir(tmpdir):
                    if file.endswith(".png"):
                        st.image(os.path.join(tmpdir, file))

        st.success("Analysis complete!")

AutoViz with Polars

from autoviz import AutoViz_Class
import polars as pl
import pandas as pd

def autoviz_polars(lf: pl.LazyFrame, target: str = "", **kwargs) -> pd.DataFrame:
    """
    Run AutoViz on Polars LazyFrame.

    Args:
        lf: Polars LazyFrame
        target: Target variable name
        **kwargs: Additional AutoViz parameters

    Returns:
        Analyzed DataFrame
    """
    # Collect LazyFrame to DataFrame, then convert to pandas
    df_polars = lf.collect()
    df_pandas = df_polars.to_pandas()

    AV = AutoViz_Class()

    return AV.AutoViz(
        filename="",
        dfte=df_pandas,
        depVar=target,
        **kwargs
    )

# Usage
# lf = pl.scan_csv("data.csv")
# df_analyzed = autoviz_polars(lf, target="revenue", chart_format="png")

Best Practices

1. Sample Large Datasets

# GOOD: Use sampling for initial exploration
AV.AutoViz(
    filename="",
    dfte=large_df,
    max_rows_analyzed=50000,  # Sample for speed
    verbose=1
)

# AVOID: Analyzing millions of rows directly
# This will be slow and may crash

2. Specify Target Variable When Available

# GOOD: Specify target for focused analysis
AV.AutoViz(
    filename="",
    dfte=df,
    depVar="target_column",  # Enables target-specific charts
    verbose=1
)

# LESS USEFUL: No target specified
# Still works but misses target-related insights

3. Choose Appropriate Chart Format

# For presentations: PNG
chart_format="png"

# For reports/web: HTML
chart_format="html"

# For notebooks: server or bokeh
chart_format="server"

# For scalable graphics: SVG
chart_format="svg"

4. Organize Output

# GOOD: Save to organized directory
import os
output_dir = f"eda_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
os.makedirs(output_dir, exist_ok=True)

AV.AutoViz(
    filename="",
    dfte=df,
    save_plot_dir=output_dir,
    chart_format="png"
)

Troubleshooting

Common Issues

Issue: Charts not displaying in Jupyter

# Solution: Use server format
%matplotlib inline
AV.AutoViz(filename="", dfte=df, chart_format="server")

Issue: Memory error with large dataset

# Solution: Reduce sample size
AV.AutoViz(
    filename="",
    dfte=df,
    max_rows_analyzed=25000,  # Reduce sample
    max_cols_analyzed=15      # Limit columns
)

Issue: Too many charts generated

# Solution: Limit columns analyzed
df_subset = df[["col1", "col2", "col3", "target"]]
AV.AutoViz(filename="", dfte=df_subset)

Issue: Categorical columns not recognized

# Solution: Convert to proper dtype
df["category"] = df["category"].astype("category")
AV.AutoViz(filename="", dfte=df)

Issue: Date columns causing issues

# Solution: Convert to datetime or extract features
df["date"] = pd.to_datetime(df["date"])
df["year"] = df["date"].dt.year
df["month"] = df["date"].dt.month
df_features = df.drop(columns=["date"])
AV.AutoViz(filename="", dfte=df_features)

Version History

• 1.0.0 (2026-01-17): Initial release
  • Basic one-line EDA functionality
  • Chart format options (png, svg, html, bokeh, server)
  • Large dataset handling with sampling
  • Feature distribution analysis
  • Correlation detection
  • Outlier identification
  • HTML and notebook export
  • Complete pipeline examples
  • Integration with Streamlit and Polars
  • Best practices and troubleshooting

Resources

• Official Documentation: https://github.com/AutoViML/AutoViz
• PyPI: https://pypi.org/project/autoviz/
• Tutorial: https://towardsdatascience.com/autoviz-a-new-tool-for-automated-visualization-ec9c1744a6ad
• Examples: https://github.com/AutoViML/AutoViz/tree/master/examples

---

Automate your exploratory data analysis with AutoViz - one line of code, comprehensive insights!