Survey Weighting in Python: Adjustment and Calibration Methods

Nonresponse adjustment, poststratification, calibration, raking, and trimming

Tutorials
Survey Weighting
Calibration
Python
Learn how to calculate and adjust survey weights in Python using the svy library. Covers nonresponse adjustment, poststratification, calibration, raking, trimming, and replicate weights for variance estimation.
Author

Mamadou S. Diallo, Ph.D.

Published

January 18, 2026

Modified

April 18, 2026

Keywords

survey weighting Python, survey weight adjustment Python, nonresponse adjustment Python, poststratification weights Python, calibration weights Python, GREG calibration Python, raking survey weights Python, iterative proportional fitting Python, design weights Python, replicate weights Python, survey weight calculation Python

Sample weighting allows analysts to generalize results from a survey sample to the target population. Design weights (also called base weights) are derived as the inverse of the final probability of selection. In large-scale surveys, these design weights are often further adjusted to correct for nonresponse, extreme values, or to align auxiliary variables with known population controls.

This tutorial covers weight adjustment techniques — nonresponse adjustment, poststratification, calibration, raking, and trimming — to improve representativeness and reduce bias.

For more on sample-weight adjustments, see Valliant and Dever (2018), which provides a step-by-step guide to calculating survey weights.

Setting Up the Sample Data

This tutorial uses the World Bank (2023) synthetic sample data.

import numpy as np
import polars as pl
from rich import print as rprint
import svy

hld_data = svy.datasets.load(name="hld_sample_wb_2023")

print(f"The number of records in the household sample data is {hld_data.shape[0]}")
The number of records in the household sample data is 8000

Weight Adjustment Methods

In practice, base weights derived from selection probabilities are routinely adjusted to:

  • Correct for nonresponse and unknown eligibility
  • Temper the influence of extreme or large weights
  • Align the weighted sample with known auxiliary controls

This section demonstrates the key methods available in the svy library:

Method Function Purpose
Nonresponse adjustment adjust() Account for unit nonresponse and unknown eligibility
Poststratification poststratify() Match weights to known control totals
Calibration calibrate() Adjust weights using GREG framework with auxiliary variables
Raking rake() Rescale weights to match multiple marginal totals
Trimming trim() Cap extreme weights to reduce variance
Normalization normalize() Rescale weights to sum to a chosen constant

Creating the Design Weight

The design weight (or base weight) represents the inverse of the overall probability of selection—the product of first-stage and second-stage selection probabilities, as explained in the Sample Selection tutorial.

# Define the sampling design
hld_design = svy.Design(stratum=("geo1", "urbrur"), psu="ea", wgt="hhweight")

# Create the sample
hld_sample = svy.Sample(data=hld_data, design=hld_design)

The dataset includes a household-level base weight variable named hhweight. Let’s rename it to base_wgt for clarity:

hld_sample = hld_sample.wrangling.rename_columns({"hhweight": "base_wgt"})

print(hld_sample)
╭────────────── Sample ───────────────╮
│ Survey Data                         │
│   Rows     : 8000                   │
│   Columns  : 52                     │
│   Strata   : 19                     │
│   PSUs     : 320                    │
│                                     │
│ Survey Design                       │
│   Row index          svy_row_index  │
│   Stratum            (geo1, urbrur) │
│   PSU                ea             │
│   SSU                None           │
│   Weight             base_wgt       │
│   With replacement   False          │
│   Prob               None           │
│   Hit                None           │
│   MOS                None           │
│   Population size    None           │
│   Replicate weights  None           │
╰─────────────────────────────────────╯

Replicate Weights

The preferred workflow is to create replicate weights early — from the design weights — and then apply the same adjustment steps (nonresponse, calibration, raking, trimming) to both the full-sample weight and the replicate weights in the same pass. This ensures that replication-based standard errors reflect all sources of variability, not just sampling variability.

svy supports five replication methods:

Method Function Requirements
BRR create_brr_wgts() Exactly 2 PSUs per stratum
Jackknife (JKn) create_jk_wgts(paired=False) ≥ 1 PSU per stratum
Jackknife (JK2) create_jk_wgts(paired=True) 2–3 PSUs per stratum
Bootstrap create_bs_wgts() ≥ 2 PSUs per stratum
SDR create_sdr_wgts() Ordered or systematic samples 
rng = np.random.default_rng(12345)

hld_sample = hld_sample.weighting.create_bs_wgts(
    n_reps=500,
    rstate=rng,
)

The replicate weights are named automatically from the active weight (e.g., base_wgt1, …, base_wgt500). You can customize the prefix with rep_prefix=....

Tip

When replicate weights are provided by the data producer (e.g., in DHS or ACS public-use files), register them directly via the RepWeights configuration in svy.Design() instead of creating them.

Understanding Response Status Categories

The core idea of nonresponse adjustment is to redistribute the survey weights of eligible non-respondents to eligible respondents within defined adjustment classes.

svy classifies records into four response categories:

Code Meaning
rr Respondent
nr Nonrespondent
uk Unknown eligible
in Ineligible

If your dataset uses different labels, provide a mapping to the canonical values:

status_mapping = {
    "in": "ineligible",
    "rr": "respondent",
    "nr": "non-respondent",
    "uk": "unknown",
}

The unknown_to_inelig parameter controls where unknowns’ weights go:

  • unknown_to_inelig=True (default) — Unknowns’ weights are redistributed proportionally to ineligibles and eligibles
  • unknown_to_inelig=False — Unknowns’ weights are not given to ineligibles; respondents’ adjusted weights are larger

Simulating Response Status

The World Bank simulated data has a 100% observed response rate. For demonstration purposes, we’ll simulate ineligibility and nonresponse:

RESPONSE_STATUS = rng.choice(
    ("ineligible", "respondent", "non-respondent", "unknown"),
    p=(0.03, 0.82, 0.10, 0.05),
    size=hld_sample.n_records,
)

hld_sample = hld_sample.wrangling.mutate({"resp_status": RESPONSE_STATUS})

# Show some eligible non-respondents in geo_01
print(
    hld_sample.show_data(
        columns=["hid", "geo1", "urbrur", "resp_status"],
        where=[
            svy.col("resp_status") == "non-respondent",
            svy.col("geo1").is_in(["geo_01"]),
        ],
        n=9,
    )
)
shape: (9, 4)
┌─────────────┬────────┬────────┬────────────────┐
│ hid         ┆ geo1   ┆ urbrur ┆ resp_status    │
│ ---         ┆ ---    ┆ ---    ┆ ---            │
│ str         ┆ str    ┆ str    ┆ str            │
╞═════════════╪════════╪════════╪════════════════╡
│ 03a770af9f0 ┆ geo_01 ┆ Urban  ┆ non-respondent │
│ 0789ea38ac1 ┆ geo_01 ┆ Urban  ┆ non-respondent │
│ 0d325ab1cec ┆ geo_01 ┆ Urban  ┆ non-respondent │
│ 1a99be8dcaf ┆ geo_01 ┆ Urban  ┆ non-respondent │
│ 1cc2796186f ┆ geo_01 ┆ Urban  ┆ non-respondent │
│ 1ec3b1b76a2 ┆ geo_01 ┆ Urban  ┆ non-respondent │
│ 1ffddef4ebe ┆ geo_01 ┆ Urban  ┆ non-respondent │
│ 2358ac5a0d0 ┆ geo_01 ┆ Urban  ┆ non-respondent │
│ 2b2063d20ee ┆ geo_01 ┆ Urban  ┆ non-respondent │
└─────────────┴────────┴────────┴────────────────┘

Nonresponse Adjustment

The adjust() method computes adjusted weights and stores them in the sample object. Adjustment classes are defined by the by parameter — they don’t have to match the sampling strata.

Setting respondents_only=True (the default) retains only respondents after adjustment, since the adjusted weights already account for all excluded units.

hld_sample = hld_sample.weighting.adjust(
    resp_status="resp_status",
    by=("geo1", "geo2"),
    resp_mapping=status_mapping,
    wgt_name="nr_wgt",
    unknown_to_inelig=True,
    respondents_only=True,
)

Verify the nr_wgt column was created:

out = hld_sample.show_data(
    columns=["hid", "geo1", "geo2", "base_wgt", "resp_status", "nr_wgt"],
    order_type="random",
    n=10,
    rstate=rng,
)

print(out)
shape: (10, 6)
┌─────────────┬────────┬───────────┬────────────┬─────────────┬────────────┐
│ hid         ┆ geo1   ┆ geo2      ┆ base_wgt   ┆ resp_status ┆ nr_wgt     │
│ ---         ┆ ---    ┆ ---       ┆ ---        ┆ ---         ┆ ---        │
│ str         ┆ str    ┆ str       ┆ f64        ┆ str         ┆ f64        │
╞═════════════╪════════╪═══════════╪════════════╪═════════════╪════════════╡
│ cf5de69b5a9 ┆ geo_04 ┆ geo_04_03 ┆ 241.999731 ┆ respondent  ┆ 280.485318 │
│ fef68b22788 ┆ geo_02 ┆ geo_02_03 ┆ 385.451143 ┆ respondent  ┆ 446.147387 │
│ ce76ca2fa32 ┆ geo_07 ┆ geo_07_01 ┆ 313.558614 ┆ respondent  ┆ 372.573648 │
│ e4737ed45f3 ┆ geo_04 ┆ geo_04_02 ┆ 304.228234 ┆ respondent  ┆ 353.724176 │
│ 1477c11d51e ┆ geo_08 ┆ geo_08_02 ┆ 302.684327 ┆ respondent  ┆ 334.433184 │
│ c03fb3f743e ┆ geo_05 ┆ geo_05_01 ┆ 355.336942 ┆ respondent  ┆ 410.907257 │
│ 20611cbc48a ┆ geo_10 ┆ geo_10_08 ┆ 341.558905 ┆ respondent  ┆ 394.878115 │
│ 283877c3de7 ┆ geo_01 ┆ geo_01_01 ┆ 256.192235 ┆ respondent  ┆ 311.061181 │
│ aba34f08f6f ┆ geo_06 ┆ geo_06_04 ┆ 314.447623 ┆ respondent  ┆ 354.129617 │
│ b9799ed0844 ┆ geo_01 ┆ geo_01_03 ┆ 224.016433 ┆ respondent  ┆ 257.817456 │
└─────────────┴────────┴───────────┴────────────┴─────────────┴────────────┘

The design is automatically updated — the active weight now points to nr_wgt:

print(hld_sample)
╭────────────────── Sample ──────────────────╮
│ Survey Data                                │
│   Rows     : 6629                          │
│   Columns  : 1054                          │
│   Strata   : 19                            │
│   PSUs     : 320                           │
│                                            │
│ Survey Design                              │
│   Row index                 svy_row_index  │
│   Stratum                   (geo1, urbrur) │
│   PSU                       ea             │
│   SSU                       None           │
│   Weight                    nr_wgt         │
│   With replacement          False          │
│   Prob                      None           │
│   Hit                       None           │
│   MOS                       None           │
│   Population size           None           │
│   Replicate weights                        │
│       Method   : Bootstrap                 │
│       Prefix   : nr_wgt                    │
│       N reps   : 500                       │
│       DF       : 499.0                     │
╰────────────────────────────────────────────╯
  • If you don’t specify wgt_name, svy creates the adjusted weight automatically as svy_adjusted_<base_weight_name>
  • Set replace=True to replace the pre-adjusted variable with the adjusted one
  • Replicate weights are adjusted in the same pass (e.g., nr_wgt1, …, nr_wgt500)

Poststratification

Poststratification compensates for under- or over-representation in the sample by adjusting weights so that weighted sums within poststratification classes match known control totals from reliable sources.

Poststratification classes need not mirror the sampling design—they can be formed from additional variables. Common choices include age group, gender, race/ethnicity, and education.

Warning

Use current, reliable controls: Poststratifying to out-of-date or unreliable totals may introduce bias rather than reduce it. Document your sources and reference dates.

Let’s assume we have reliable control totals (e.g., from a recent census) for households per administrative region:

hld_control_totals = {
    "geo_01": 342_000,
    "geo_02": 240_000,
    "geo_03": 282_000,
    "geo_04": 370_000,
    "geo_05": 210_000,
    "geo_06": 185_000,
    "geo_07": 183_000,
    "geo_08": 105_000,
    "geo_09": 300_000,
    "geo_10": 290_000,
}

Apply poststratification to the nonresponse-adjusted weights:

hld_sample = hld_sample.weighting.poststratify(
    controls=hld_control_totals,
    by="geo1",
    wgt_name="ps_wgt",
)

Verify the ps_wgt column was created:

out = hld_sample.show_data(
    columns=["hid", "geo1", "nr_wgt", "ps_wgt"],
    n=10,
    order_type="random",
    order_by="geo1",
    rstate=rng,
)

print(out)
shape: (10, 4)
┌─────────────┬────────┬────────────┬────────────┐
│ hid         ┆ geo1   ┆ nr_wgt     ┆ ps_wgt     │
│ ---         ┆ ---    ┆ ---        ┆ ---        │
│ str         ┆ str    ┆ f64        ┆ f64        │
╞═════════════╪════════╪════════════╪════════════╡
│ ac3d8fd3132 ┆ geo_01 ┆ 399.763944 ┆ 409.891698 │
│ 7bff2554ec4 ┆ geo_01 ┆ 330.621354 ┆ 338.997426 │
│ 4e173001b6c ┆ geo_01 ┆ 507.919258 ┆ 520.787055 │
│ 1a72ab318f7 ┆ geo_01 ┆ 524.717911 ┆ 538.011291 │
│ 4a11dd23063 ┆ geo_01 ┆ 392.143479 ┆ 402.078173 │
│ 80bb1caabff ┆ geo_01 ┆ 392.143479 ┆ 402.078173 │
│ 90bd109b1ef ┆ geo_01 ┆ 210.834409 ┆ 216.175758 │
│ 180ca8fda9e ┆ geo_01 ┆ 473.455579 ┆ 485.450261 │
│ b2306b362b6 ┆ geo_01 ┆ 381.823914 ┆ 391.497169 │
│ d0d3de25660 ┆ geo_01 ┆ 507.919258 ┆ 520.787055 │
└─────────────┴────────┴────────────┴────────────┘

The sample design is automatically updated with the new weight:

print(hld_sample)
╭────────────────── Sample ──────────────────╮
│ Survey Data                                │
│   Rows     : 6629                          │
│   Columns  : 1555                          │
│   Strata   : 19                            │
│   PSUs     : 320                           │
│                                            │
│ Survey Design                              │
│   Row index                 svy_row_index  │
│   Stratum                   (geo1, urbrur) │
│   PSU                       ea             │
│   SSU                       None           │
│   Weight                    ps_wgt         │
│   With replacement          False          │
│   Prob                      None           │
│   Hit                       None           │
│   MOS                       None           │
│   Population size           None           │
│   Replicate weights                        │
│       Method   : Bootstrap                 │
│       Prefix   : ps_wgt                    │
│       N reps   : 500                       │
│       DF       : 499.0                     │
╰────────────────────────────────────────────╯

Calibration (GREG)

Calibration adjusts sample weights so that certain totals align with known population values. The Generalized Regression (GREG) approach is a model-assisted version that assumes the survey variable of interest relates to auxiliary variables through a regression-type relationship. See Deville and Särndal (1992) for the foundational work on calibration, and Särndal, Swensson, and Wretman (1992) for a thorough treatment of model-assisted survey sampling.

GREG calibration finds weights that:

  • Stay as close as possible to the original design weights
  • Make the weighted totals of auxiliary variables match their known population values

Unlike poststratification, which adjusts weights within discrete cells, GREG can incorporate continuous auxiliary information, leveraging the linear relationship between the covariate and the study variable to potentially improve efficiency.

The controls dictionary uses svy.Cat() to wrap categorical variables and a plain string key for continuous ones:

controls = {
    svy.Cat("statocc"): {
        "Occupied for free": 250_000,
        "Owned": 1_932_000,
        "Rented": 325_000,
    },
    "hhsize": 10_004_000,
}

Apply calibration:

hld_sample = hld_sample.weighting.calibrate(
    controls=controls,
    wgt_name="cal_wgt",
)

Verify the calibrated weights:

out = hld_sample.show_data(
    columns=["hid", "statocc", "hhsize", "ps_wgt", "cal_wgt"],
    order_type="random",
    order_by="statocc",
    rstate=rng,
)

print(out)
shape: (5, 5)
┌─────────────┬───────────────────┬────────┬────────────┬────────────┐
│ hid         ┆ statocc           ┆ hhsize ┆ ps_wgt     ┆ cal_wgt    │
│ ---         ┆ ---               ┆ ---    ┆ ---        ┆ ---        │
│ str         ┆ str               ┆ i64    ┆ f64        ┆ f64        │
╞═════════════╪═══════════════════╪════════╪════════════╪════════════╡
│ a47f27fd959 ┆ Occupied for free ┆ 4      ┆ 242.550447 ┆ 241.838078 │
│ 730e162cda0 ┆ Occupied for free ┆ 1      ┆ 407.620337 ┆ 417.372755 │
│ 930a60bcf98 ┆ Occupied for free ┆ 1      ┆ 551.911578 ┆ 565.1162   │
│ 782904c199f ┆ Occupied for free ┆ 1      ┆ 499.150685 ┆ 511.09299  │
│ 0bfeabbfc30 ┆ Occupied for free ┆ 4      ┆ 317.673762 ┆ 316.740757 │
└─────────────┴───────────────────┴────────┴────────────┴────────────┘
Tip

Calibration can also be performed within domains via the by parameter, which is useful when domain-level control totals are available and the relationship between auxiliary variables and the survey outcome varies across domains.

Raking (Iterative Proportional Fitting)

Raking (also called iterative proportional fitting or IPF) adjusts survey weights so that weighted sample distributions match known population margins for several categorical variables.

Unlike calibration, which aligns multiple totals simultaneously, raking updates weights iteratively—adjusting one margin at a time until all specified margins agree with population controls within tolerance.

Raking is especially useful when only marginal totals are available (e.g., totals by tenure status and totals by electricity access, but not their cross-tabulation).

Define the marginal control totals:

raking_controls = {
    "statocc": {
        "Occupied for free": 250_000,
        "Owned": 1_932_000,
        "Rented": 325_000,
    },
    "electricity": {"No": 425_000, "Yes": 2_082_000},
}

rprint(raking_controls)
{
    'statocc': {'Occupied for free': 250000, 'Owned': 1932000, 'Rented': 325000},
    'electricity': {'No': 425000, 'Yes': 2082000}
}

Apply raking:

hld_sample = hld_sample.weighting.rake(
    controls=raking_controls,
    wgt_name="rake_wgt",
    tol=1e-6,
)

Verify the raked weights:

out = hld_sample.show_data(
    columns=["hid", "statocc", "electricity", "cal_wgt", "rake_wgt"],
    n=10,
    order_by=("statocc", "electricity"),
    order_type="random",
    rstate=rng,
)

print(out)
shape: (10, 5)
┌─────────────┬───────────────────┬─────────────┬────────────┬────────────┐
│ hid         ┆ statocc           ┆ electricity ┆ cal_wgt    ┆ rake_wgt   │
│ ---         ┆ ---               ┆ ---         ┆ ---        ┆ ---        │
│ str         ┆ str               ┆ str         ┆ f64        ┆ f64        │
╞═════════════╪═══════════════════╪═════════════╪════════════╪════════════╡
│ 930a60bcf98 ┆ Occupied for free ┆ No          ┆ 565.1162   ┆ 563.180626 │
│ 4b47172f406 ┆ Occupied for free ┆ No          ┆ 289.307288 ┆ 288.316384 │
│ 9974467f1f0 ┆ Occupied for free ┆ No          ┆ 346.981908 ┆ 345.793463 │
│ 7f4e816138f ┆ Occupied for free ┆ No          ┆ 322.19723  ┆ 321.093675 │
│ 760d1268159 ┆ Occupied for free ┆ No          ┆ 278.987393 ┆ 278.031835 │
│ 3bdc6e31f82 ┆ Occupied for free ┆ No          ┆ 411.697994 ┆ 410.287891 │
│ d3e45b7d943 ┆ Occupied for free ┆ No          ┆ 241.838078 ┆ 241.00976  │
│ 7a7bc823c36 ┆ Occupied for free ┆ No          ┆ 449.707983 ┆ 448.167692 │
│ 0c4a30de8c4 ┆ Occupied for free ┆ No          ┆ 401.670634 ┆ 400.294875 │
│ f5364673803 ┆ Occupied for free ┆ No          ┆ 458.555042 ┆ 456.98445  │
└─────────────┴───────────────────┴─────────────┴────────────┴────────────┘

Weight Trimming

Trimming caps extreme survey weights that can arise from nonresponse adjustment, calibration, or unequal selection probabilities. Untrimmed extreme weights inflate the variance of survey estimates and can cause individual observations to dominate weighted totals. Trimming reduces this instability at the cost of introducing a small bias.

svy provides Cap for specifying stat-based thresholds:

Threshold Description
svy.Cap("median", k) k × median
svy.Cap("mean", k) k × mean
svy.Cap("sd", k) k × standard deviation
svy.Cap("iqr", k) k × interquartile range (Q75 − Q25)
Float in (0, 1] Quantile (e.g., 0.99 for the 99th percentile)
Float > 1 Absolute threshold

Cap supports composition via +, -, and * operators, which is useful for common rules like the boxplot threshold (median + k × IQR):

# Simple: 3.5 × median
svy.Cap("median", 3.5)

# Composed: median + 6 × IQR (boxplot rule)
svy.Cap("median") + 6 * svy.Cap("iqr")

# Composed: mean + 3 × SD
svy.Cap("mean") + 3 * svy.Cap("sd")

# Lower bound: mean - 2 × SD
svy.Cap("mean") - 2 * svy.Cap("sd")

When redistribute=True (the default), mass removed from trimmed units is redistributed proportionally to the remaining units so the total weighted sample size is preserved.

hld_sample = hld_sample.weighting.trim(
    upper=svy.Cap("median") + 3.5 * svy.Cap("iqr"),
    wgt_name="trim_wgt",
    redistribute=True,
    by=("geo1", "urbrur")
)
out = hld_sample.show_data(
    columns=["hid", "geo1", "rake_wgt", "trim_wgt"],
    where=svy.col("rake_wgt") != svy.col("trim_wgt"),
    order_type="random",
    rstate=rng,
)

print(out)
shape: (0, 4)
┌─────┬──────┬──────────┬──────────┐
│ hid ┆ geo1 ┆ rake_wgt ┆ trim_wgt │
│ --- ┆ ---  ┆ ---      ┆ ---      │
│ str ┆ str  ┆ f64      ┆ f64      │
╞═════╪══════╪══════════╪══════════╡
└─────┴──────┴──────────┴──────────┘

Integrated Trimming

Standalone trimming is a one-shot operation: weights are capped but the raking or calibration constraints may no longer hold. svy addresses this through the trimming parameter available on rake(), poststratify(), and calibrate().

When trimming is specified, the method runs an iterative cycle: rake (or calibrate) the weights, then trim, then repeat until both constraints are satisfied simultaneously. The final step is always a raking (or calibration) pass so that the margin constraints take priority.

# Raking with simultaneous trimming
hld_sample = hld_sample.weighting.rake(
    controls=raking_controls,
    wgt_name="rk_trim_wgt",
    trimming=svy.TrimConfig(
        upper=svy.Cap("median") + 3.5 * svy.Cap("iqr"),
        redistribute=True,
        by=("geo1", "urbrur"),
    ),
)

The TrimConfig object encapsulates all trimming parameters (threshold, redistribution, convergence tolerance, maximum iterations) into a single specification that can be passed to any weighting method.

Weight Normalization

Surveys sometimes normalize weights to a convenient constant (e.g., the sample size or 1,000) so results are easier to compare across analyses.

Normalization multiplies every weight by the same factor. It does not change weighted means, proportions, or regression coefficients (the factor cancels), but it does change level estimates such as totals by the same factor.

hld_sample = hld_sample.weighting.normalize(
    controls=1_000,
    wgt_name="norm_wgt",
)

print(f"Normalized weight sum: {hld_sample.data['norm_wgt'].sum():.1f}")
Normalized weight sum: 1000.0

Summary

This tutorial covered the essential techniques for survey weight adjustment:

  1. Replicate weights with create_bs_wgts() / create_jk_wgts() / create_brr_wgts() — create replicate weights early so all adjustments propagate automatically
  2. Nonresponse adjustment with adjust() — redistributes weights from non-respondents to respondents
  3. Poststratification with poststratify() — aligns weights to known population totals within cells
  4. Calibration with calibrate() — uses GREG framework with both categorical and continuous auxiliary variables
  5. Raking with rake() — iteratively matches multiple marginal distributions
  6. Trimming with trim() — caps extreme weights; also available as integrated trimming via TrimConfig
  7. Normalization with normalize() — scales weights to a convenient total
Tip

The recommended workflow order is: design weights → replicate weights → nonresponse adjustment → calibration or raking (with optional integrated trimming) → normalization. Each step automatically updates both the full-sample weight and the replicate weights.

Next Steps

Now that you understand how to create and adjust survey weights, continue to the estimation tutorial to learn how to produce design-adjusted estimates.

Ready to estimate?
Learn about design-adjusted estimation in Survey Estimation →

References

  • Deville, J.-C., & Särndal, C.-E. (1992). Calibration estimators in survey sampling. Journal of the American Statistical Association, 87(418), 376–382.
  • Särndal, C.-E., Swensson, B., & Wretman, J. (1992). Model Assisted Survey Sampling. Springer.
  • Valliant, R., Dever, J. A., & Kreuter, F. (2018). Practical Tools for Designing and Weighting Survey Samples (2nd ed.). Springer.

References

Deville, Jean-Claude, and Carl-Erik Särndal. 1992. “Calibration Estimators in Survey Sampling.” J. Amer. Statist. Assoc. 87 (418): 376–82. https://doi.org/10.1080/01621459.1992.10475217.
Särndal, Carl-Erik, Bengt Swensson, and Jan Wretman. 1992. Model Assisted Survey Sampling. Springer-Verlag New York, Inc. https://link.springer.com/book/9780387406206.
Valliant, R, and J A Dever. 2018. Survey Weights: A Step-by-Step Guide to Calculation. Stata Press. https://www.stata-press.com/books/survey-weights/.
World Bank. 2023. “Synthetic Data for an Imaginary Country, Sample, 2023.” World Bank, Development Data Group. https://doi.org/10.48529/MC1F-QH23.