Synthetic Control Methods (SCM)

The SynthBase class acts as a central container for all variables, processed matrices, and results generated during the synthetic control procedure. It is used internally by Synth and DiffSynth to store state.

Key Data Matrices

• treated_outcome: (1 x pre-treatment periods) Outcome of the treated unit in the pre-treatment period.
• control_outcome: (n_controls x pre-treatment periods) Outcomes of all control units in the pre-treatment period.
• treated_covariates: (n_covariates x 1) Average value of each predictor for the treated unit in the pre-treatment period.
• control_covariates: (n_covariates x n_controls) Average value of each predictor for each control unit in the pre-treatment period.
• w: (1 x n_controls) The weights assigned to each control unit (must be non-negative and sum to 1).
• v: (n_covariates x n_covariates) A diagonal, positive semi-definite matrix representing the relative importance of each covariate.
• weight_df: A DataFrame containing the calculated unit weights.
• comparison_df: A DataFrame containing the comparison between the treated and synthetic units.

To use Synth or DiffSynth, your dataset must adhere to these formatting requirements:

1. Numerical Variables: All variables must be numerical, except for a single categorical unit identifier (e.g., country).
2. Sorting: The dataset must be sorted by unit and then by time (all observations for a single unit must appear consecutively).
3. Unit Identifier: Use exactly one unit identifier column. If your data has multiple (e.g., code and country), drop one or use the exclude_columns argument.
4. Units: The dataset must contain one treated unit and multiple control units.
5. Missing Values:
   • Outcome: No missing values are allowed in the outcome column. You must impute or drop missing outcome data before processing.
   • Covariates: Missing values are allowed in covariates. Synth() ignores them (using pre-treatment averages), while DiffSynth() automatically applies linear interpolation to impute them.

The Synth class is the primary interface for estimating causal effects using the synthetic control method. It requires a pandas DataFrame containing your panel data.

Parameters for Synth():

• data: A pandas.DataFrame containing the observations.
• outcome_col: The name of the column representing the outcome of interest.
• unit_col: The name of the column representing the unit ID (e.g., 'country').
• time_col: The name of the column representing the time period (e.g., 'year').
• treatment_year: The year/period when the intervention occurred.
• treated_unit: The identifier for the unit that received the treatment.
• pen: Penalty parameter (default is 0).

Methods:

• plot(types, ...): Visualizes the results. types can be a list containing "original", "pointwise", and "cumulative".

import pandas as pd
from SyntheticControlMethods import Synth

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

# Initialize and fit the model
sc = Synth(data, "outcome_column", "unit_column", "time_column", 1990, "Treated Unit Name", pen=0)

# Visualize the results
sc.plot(["original", "pointwise", "cumulative"], 
        treated_label="Treated Unit", 
        synth_label="Synthetic Unit", 
        treatment_label="Intervention Name")

The DiffSynth() class implements Differenced Synthetic Controls. This method is useful if the ordinary Synth() fails (e.g., if the treated unit's outcome is more extreme than any control unit) because it focuses on matching the change in the outcome rather than the absolute level.

Arguments:

• All arguments from Synth().
• not_diff_cols: A list of column names to omit from the first-differencing process. Use this for covariates with high missingness where differencing is not meaningful.

Note on Interpretation: In the comparison_df attribute, DiffSynth displays the average change in covariate values instead of the absolute average values.

from SyntheticControlMethods import DiffSynth

# Fit differenced synthetic control
# We exclude certain columns from differencing due to high missingness
dsc = DiffSynth(
    data, 
    "gdp", 
    "country", 
    "year", 
    1990, 
    "West Germany", 
    not_diff_cols=["schooling", "invest60"],
    n_optim=100
)

The Synth class implements the standard Synthetic Control Method (SCM). It estimates a synthetic version of a treated unit by assigning weights to control units to match the treated unit's pre-treatment characteristics.

Initialization Parameters

• dataset: A Pandas DataFrame containing the observations. The dataset must be sorted by ID and then by Time.
• outcome_var: Name of the outcome column (e.g., 'gdp').
• id_var: Name of the unit identifier column (e.g., 'country').
• time_var: Name of the time period column (e.g., 'year').
• treatment_period: The first time period after treatment occurred (the first period affected by the effect).
• treated_unit: The ID of the unit that received the treatment.
• n_optim: (int, default: 10) Number of different initialization values for optimization. Higher values increase the chance of finding a global optimum but increase runtime.
• pen: (float, default: 0) Penalization coefficient. Higher values increase the importance of minimizing the pairwise difference of individual control units from the treated unit.

from SyntheticControlMethods.main import Synth
import pandas as pd

# Example setup
df = pd.read_csv('your_data.csv')
synth = Synth(
    dataset=df,
    outcome_var='gdp',
    id_var='country',
    time_var='year',
    treatment_period=1990,
    treated_unit='West Germany',
    n_optim=20,
    pen=0.1
)

The DiffSynth class implements the Differenced Synthetic Control Method (DSC). This method is useful when working with first-differences of variables to account for non-stationarity.

Initialization Parameters

In addition to the standard Synth parameters, DiffSynth includes:

• not_diff_cols: (list, default: []) A list of column names to omit from the first-differencing process. This is useful for columns where the first difference is not appropriate (e.g., if the proportion of missing values is high).

Data Transformation

DiffSynth automatically performs the following on the provided dataset:

1. Linear Interpolation: Imputes missing values using linear interpolation to ensure consecutive periods are present (required for differencing).
2. First Differencing: Computes the change from the previous time period for the outcome and specified covariates.
3. Dropping Initial Periods: Removes the first time period for every unit since the change from the previous period is undefined.

from SyntheticControlMethods.main import DiffSynth

# Example setup for Differenced Synthetic Control
diff_synth = DiffSynth(
    dataset=df,
    outcome_var='gdp',
    id_var='country',
    time_var='year',
    treatment_period=1990,
    treated_unit='West Germany',
    not_diff_cols=['some_stable_covariate']
)