contribution-analysis

Calculate the relative contribution of different factors to a response variable using R² decomposition. Use when you need to quantify how much each factor ex...

Security Scan

The skill's instructions mostly match its stated purpose (R² decomposition) but contain several inconsistencies, missing dependency declarations, and an output bug that make the guidance unreliable without fixes.

Purpose & Capability

Name and description (contribution analysis via R² decomposition) align with the instructions, which implement factor scores and drop-one R² comparisons. However, the prose says to run a global PCA while the example code uses FactorAnalyzer (factor analysis), and variable names (pca_vars) conflict with the chosen method.

Instruction Scope

The SKILL.md runs entirely in-process on a dataframe (df) and writes output.csv locally — no network or secret access — which is reasonable. However the instructions have functional issues: (1) the example computes only the dominant contribution to output.csv (it writes only one row) instead of writing all category contributions as the guide implies; (2) drop-one R² differences are order-dependent and can be negative (the guide notes this but treats it lightly); (3) the method may produce misleading attribution when predictors/factors are correlated or when factors are derived and then immediately regressed on the same data (risk of inflated R²).

Install Mechanism

This is instruction-only (no install spec) which is low risk, but the runtime example requires Python packages (pandas, numpy, scikit-learn, factor_analyzer) that are not declared anywhere in the skill metadata. Users need to install these dependencies themselves.

Credentials

The skill requests no environment variables, credentials, or privileged paths. It only assumes access to an in-memory dataframe and local filesystem write permission for output.csv.

Persistence & Privilege

The skill has no install or persistence, always:false, and does not request elevated or cross-skill configuration changes.

What to consider before installing

This skill appears to implement R² decomposition via factor scores, but several issues need attention before you rely on it: (1) fix the PCA vs FactorAnalyzer mismatch — decide whether to use PCA or factor analysis and update the text and variable names accordingly; (2) declare required Python packages (pandas, numpy, scikit-learn, factor_analyzer) so consumers know what to install; (3) correct the output: the example writes only the dominant category to output.csv rather than all contributions — if you need full results, modify the write block to export every category and its percentage; (4) be cautious: drop-one R² contributions can be negative and are not a unique or fair allocation when predictors/factors are correlated. Consider alternate attribution methods (e.g., Shapley values, dominance analysis, permutation importance, or cross-validated R²) and using cross-validation or a holdout set so R² estimates are not overly optimistic; (5) test the pipeline on synthetic data to confirm factor-to-category mapping and contribution sums before using results in reports. If the author provides corrected example code and dependency metadata, confidence in the skill would increase.

Contribution Analysis Guide

Overview

Contribution analysis quantifies how much each factor contributes to explaining the variance of a response variable. This skill focuses on R² decomposition method.

Complete Workflow

When you have multiple correlated variables that belong to different categories:

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression
from factor_analyzer import FactorAnalyzer

# Step 1: Combine ALL variables into one matrix
pca_vars = ['Var1', 'Var2', 'Var3', 'Var4', 'Var5', 'Var6', 'Var7', 'Var8']
X = df[pca_vars].values
y = df['ResponseVariable'].values

# Step 2: Standardize
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# Step 3: Run ONE global PCA on all variables together
fa = FactorAnalyzer(n_factors=4, rotation='varimax')
fa.fit(X_scaled)
scores = fa.transform(X_scaled)

# Step 4: R² decomposition on factor scores
def calc_r2(X, y):
    model = LinearRegression()
    model.fit(X, y)
    y_pred = model.predict(X)
    ss_res = np.sum((y - y_pred) ** 2)
    ss_tot = np.sum((y - np.mean(y)) ** 2)
    return 1 - (ss_res / ss_tot)

full_r2 = calc_r2(scores, y)

# Step 5: Calculate contribution of each factor
contrib_0 = full_r2 - calc_r2(scores[:, [1, 2, 3]], y)
contrib_1 = full_r2 - calc_r2(scores[:, [0, 2, 3]], y)
contrib_2 = full_r2 - calc_r2(scores[:, [0, 1, 3]], y)
contrib_3 = full_r2 - calc_r2(scores[:, [0, 1, 2]], y)

R² Decomposition Method

The contribution of each factor is calculated by comparing the full model R² with the R² when that factor is removed:

Contribution_i = R²_full - R²_without_i

Output Format

contributions = {
    'Category1': contrib_0 * 100,
    'Category2': contrib_1 * 100,
    'Category3': contrib_2 * 100,
    'Category4': contrib_3 * 100
}

dominant = max(contributions, key=contributions.get)
dominant_pct = round(contributions[dominant])

with open('output.csv', 'w') as f:
    f.write('variable,contribution\n')
    f.write(f'{dominant},{dominant_pct}\n')

Common Issues

Issue	Cause	Solution
Negative contribution	Suppressor effect	Check for multicollinearity
Contributions don't sum to R²	Normal behavior	R² decomposition is approximate
Very small contributions	Factor not important	May be negligible driver

Best Practices

• Run ONE global PCA on all variables together, not separate PCA per category
• Use factor_analyzer with varimax rotation
• Map factors to category names based on loadings interpretation
• Report contribution as percentage
• Identify the dominant (largest) factor