Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
# Create a new Quarto document
quarto create-project my-report --type document
Core Workflow
Step 1: Basic Quarto Document Structure
The following shows the structure of a complete Quarto .qmd file. Save as analysis_report.qmd:
---
title: "Regression Analysis Report"
subtitle: "Quantitative Research Summary"
author:
- name: "Research Team"
affiliation: "University Department"
date: today
abstract: |
This report presents a regression analysis of the simulated dataset.
Key findings include a statistically significant positive relationship
between the predictor and outcome variables.
format:
html:
toc: true
toc-depth: 3
code-fold: true
number-sections: true
theme: cosmo
fig-width: 8
fig-height: 5
pdf:
documentclass: article
geometry: "margin=1in"
number-sections: true
execute:
echo: true
warning: false
message: false
jupyter: python3
---
# Introduction {#sec-intro}
This report analyzes a synthetic dataset to demonstrate reproducible reporting
with Quarto. See @sec-methods for the analytical approach.
# Methods {#sec-methods}## Data Generation```{python}
#| label: setup
#| include: false
import numpy as np
import pandas as pd
import statsmodels.api as sm
import matplotlib.pyplot as plt
from IPython.display import display
np.random.seed(42)
```
We simulated $n = 200$ observations from a linear model
$Y = \beta_0 + \beta_1 X_1 + \beta_2 X_2 + \varepsilon$ where
$\varepsilon \sim \mathcal{N}(0, \sigma^2)$.
```{python}
#| label: data-generation
n = 200
x1 = np.random.normal(5, 2, n)
x2 = np.random.binomial(1, 0.5, n)
y = 3.0 + 1.5 * x1 + 2.0 * x2 + np.random.normal(0, 3, n)
df = pd.DataFrame({"y": y, "x1": x1, "x2": x2})
print(f"Dataset: {len(df)} observations, {df.shape[1]} variables")
```
## Analytical Approach
We fit an OLS regression model and report heteroskedasticity-robust
standard errors (HC3).
# Results {#sec-results}
## Descriptive Statistics
```{python}
#| label: tbl-descriptive
#| tbl-cap: "Descriptive statistics for all variables."
desc = df.describe().round(2)
display(desc)
```
@tbl-descriptive presents the descriptive statistics.
## Regression Results
```{python}
#| label: regression-model
X = sm.add_constant(df[["x1", "x2"]])
model = sm.OLS(df["y"], X).fit(cov_type="HC3")
```
The regression results are shown in @tbl-regression.
```{python}
#| label: tbl-regression
#| tbl-cap: "OLS regression results with HC3 standard errors."
results_df = pd.DataFrame({
"Coefficient": model.params,
"Std. Error": model.bse,
"t-stat": model.tvalues,
"p-value": model.pvalues,
"95% CI Lower": model.conf_int()[0],
"95% CI Upper": model.conf_int()[1],
}).round(3)
display(results_df)
```
The model explains `{python} f"{model.rsquared_adj:.3f}"` of the variance
in the outcome ($\bar{R}^2$).
## Visualization```{python}
#| label: fig-scatter
#| fig-cap: "Scatter plot of X1 vs. Y by group X2."
#| fig-width: 6
#| fig-height: 4
fig, ax = plt.subplots(figsize=(6, 4))
for x2_val, color, label in [(0, "steelblue", "X2=0"), (1, "orange", "X2=1")]:
mask = df["x2"] == x2_val
ax.scatter(df.loc[mask, "x1"], df.loc[mask, "y"],
color=color, alpha=0.5, s=20, label=label)
# Fitted lines
xf = np.linspace(df["x1"].min(), df["x1"].max(), 100)
for x2_val, color in [(0, "steelblue"), (1, "orange")]:
yf = model.params["const"] + model.params["x1"] * xf + model.params["x2"] * x2_val
ax.plot(xf, yf, color=color, lw=2)
ax.set_xlabel("X1"); ax.set_ylabel("Y")
ax.set_title("Fitted Regression Lines by Group")
ax.legend()
plt.tight_layout()
plt.show()
```
@fig-scatter shows the relationship between X1 and Y, stratified by X2.
# Discussion {#sec-discussion}
The coefficient for X1 ($\hat{\beta}_1 = `{python} f"{model.params['x1']:.3f}"`$,
$p `{python} "< 0.001" if model.pvalues['x1'] < 0.001 else f"= {model.pvalues['x1']:.3f}"`$)
indicates a positive relationship.
# Conclusion {#sec-conclusion}
This analysis demonstrates Quarto's capabilities for reproducible reporting.
All figures and tables were generated from the same code that produced
the written results.
# References {.unnumbered}
::: {#refs}
:::
# Render to HTML
quarto render analysis_report.qmd --to html
# Render to PDF
quarto render analysis_report.qmd --to pdf
# Render all formats defined in YAML
quarto render analysis_report.qmd
Step 2: Parameterized Report Generation
# File: generate_reports.py"""Automate parameterized Quarto report generation."""import subprocess
import os
import json
from pathlib import Path
defrender_parameterized_report(
qmd_file,
output_dir,
params,
output_format="html",
):
"""Render a Quarto report with specific parameter values.
Args:
qmd_file: Path to .qmd source file
output_dir: Directory to save output
params: dict of parameter name → value
output_format: output format string
Returns:
Path to rendered output file, or None on failure
"""
Path(output_dir).mkdir(parents=True, exist_ok=True)
# Build parameter flags
param_flags = []
for key, value in params.items():
param_flags.extend(["-P", f"{key}:{value}"])
# Output file name
output_file = Path(output_dir) / f"report_{params.get('dataset', 'default')}.{output_format}"
cmd = [
"quarto", "render", qmd_file,
"--to", output_format,
"--output", str(output_file),
] + param_flags
print(f"Rendering: {' '.join(cmd)}")
result = subprocess.run(cmd, capture_output=True, text=True)
if result.returncode == 0:
print(f"Success: {output_file}")
return output_file
else:
print(f"Error rendering {qmd_file}:")
print(result.stderr)
returnNone# Example: Generate reports for multiple datasets
datasets = ["2021", "2022", "2023"]
for year in datasets:
render_parameterized_report(
qmd_file="analysis_report.qmd",
output_dir="reports/",
params={"year": year, "alpha": "0.05"},
output_format="html",
)
# Example: Batch generation with different parameter combinationsfrom itertools import product
alphas = [0.01, 0.05]
methods = ["ols", "wls"]
for alpha, method in product(alphas, methods):
report = render_parameterized_report(
"sensitivity_analysis.qmd",
"reports/sensitivity/",
{"alpha": str(alpha), "method": method},
)
Step 3: Quarto Book and Website Setup
# Create a research book project
quarto create-project my-research-book --type book
# Generate a results section text from statistical outputimport numpy as np
import pandas as pd
import statsmodels.api as sm
defformat_p_value(p):
"""Format p-value for publication."""if p < 0.001: return"< .001"elif p < 0.01: returnf"= {p:.3f}"else: returnf"= {p:.3f}"defregression_results_text(model, predictor):
"""Generate APA-style regression results text."""
coeff = model.params[predictor]
se = model.bse[predictor]
t = model.tvalues[predictor]
p = model.pvalues[predictor]
ci_lo, ci_hi = model.conf_int().loc[predictor]
return (
f"The predictor {predictor} was "f"{'significantly'if p < 0.05else'not significantly'} "f"associated with the outcome, "f"b = {coeff:.2f}, SE = {se:.2f}, "f"t({int(model.df_resid)}) = {t:.2f}, p {format_p_value(p)}, "f"95% CI [{ci_lo:.2f}, {ci_hi:.2f}]."
)
np.random.seed(42)
x = np.random.normal(0, 1, 100)
y = 2.5 * x + np.random.normal(0, 1, 100)
model = sm.OLS(y, sm.add_constant(pd.DataFrame({"x": x}))).fit()
print("Generated results text:")
print(regression_results_text(model, "x"))
Example 2: Table Formatting for Publication
import pandas as pd
import numpy as np
defformat_regression_table(models_dict, variable_labels=None):
"""Create publication-ready regression comparison table.
Args:
models_dict: dict of {model_name: statsmodels result}
variable_labels: dict of {variable: display_name}
Returns:
DataFrame suitable for display in Quarto
"""if variable_labels isNone:
variable_labels = {}
all_vars = set()
for model in models_dict.values():
all_vars.update(model.params.index)
all_vars = sorted(all_vars)
rows = []
for var in all_vars:
row = {"Variable": variable_labels.get(var, var)}
for model_name, model in models_dict.items():
if var in model.params:
coef = model.params[var]
se = model.bse[var]
p = model.pvalues[var]
stars = "***"if p < 0.001else"**"if p < 0.01else"*"if p < 0.05else""
row[model_name] = f"{coef:.3f}{stars}\n({se:.3f})"else:
row[model_name] = "—"
rows.append(row)
df = pd.DataFrame(rows)
# Add fit statisticsfor stat_name, stat_fn in [("R²", lambda m: f"{m.rsquared:.3f}"),
("Adj. R²", lambda m: f"{m.rsquared_adj:.3f}"),
("N", lambda m: str(int(m.nobs)))]:
row = {"Variable": stat_name}
for model_name, model in models_dict.items():
row[model_name] = stat_fn(model)
rows.append(row)
return pd.DataFrame(rows)
# Demo
np.random.seed(42)
n = 200
x1 = np.random.normal(0, 1, n)
x2 = np.random.normal(0, 1, n)
y = 1.5 * x1 + 0.8 * x2 + np.random.normal(0, 1, n)
import statsmodels.api as sm
m1 = sm.OLS(y, sm.add_constant(pd.DataFrame({"x1": x1}))).fit()
m2 = sm.OLS(y, sm.add_constant(pd.DataFrame({"x1": x1, "x2": x2}))).fit()
table = format_regression_table({"Model 1": m1, "Model 2": m2},
{"const": "Intercept", "x1": "Predictor 1", "x2": "Predictor 2"})
print("Publication-ready regression table:")
print(table.to_string(index=False))
