Automatic exploratory data analysis and visualization with a single line of code - generates comprehensive charts, detects patterns, and exports to HTML/notebooks
Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.
Quelldateien prüfen
Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.
Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.
Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.
Automatic exploratory data analysis and visualization with a single line of code - generates comprehensive charts, detects patterns, and exports to HTML/notebooks
author
workspace-hub
category
data-analysis
capabilities
["One-line automatic EDA","Feature distribution analysis","Correlation detection and visualization","Outlier identification and highlighting","Automated chart type selection","Export to HTML and Jupyter notebooks","Support for large datasets with sampling","Categorical and numerical feature analysis"]
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
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 filesfor 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 inrange(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
defanalyze_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(1for _ inopen(file_path)) - 1# Exclude headerif 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 > 0and 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
defanalyze_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() iflen(outliers) > 0elseNone,
"max_outlier": outliers[col].max() iflen(outliers) > 0elseNone
}
# 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
defgenerate_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")
withopen(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 Notebookfrom 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
defcreate_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
withopen(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
defsales_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 dataprint("Loading data...")
df = pd.read_csv(data_path)
# Basic data infoprint(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]
iflen(missing_df) > 0:
print(f"\nMissing values:\n{missing_df}")
else:
print("\nNo missing values found")
# Run AutoVizprint("\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")
withopen(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 testingdefgenerate_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
defml_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) elseNone,
"std": X[col].std() if np.issubdtype(X[col].dtype, np.number) elseNone
}
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 datasetdefcreate_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 inrange(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 datasetdefcreate_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 inrange(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")
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 isnotNone:
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 outputswith 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
defautoviz_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 directoryimport 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")
