import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LassoCV
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

df = pd.read_csv("dataset.csv")

y = df["G3"]
numeric = ["G1", "G2", "studytime", "failures",
           "absences", "age", "Medu", "Fedu"]
categorical = ["school", "sex", "address", "famsize"]
X = df[numeric + categorical]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.251, random_state=42
)

numeric_pipe = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),
])

categorical_pipe = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("encoder", OneHotEncoder(drop="first", handle_unknown="ignore")),
])

preprocessor = ColumnTransformer([
    ("numeric", numeric_pipe, numeric),
    ("categorical", categorical_pipe, categorical),
])

model = Pipeline([
    ("preprocess", preprocessor),
    ("lasso", LassoCV(cv=5, max_iter=100000, random_state=42)),
])

model.fit(X_train, y_train)
pred = model.predict(X_test)

rmse = mean_squared_error(y_test, pred) ** 0.5
mae = mean_absolute_error(y_test, pred)
r2 = r2_score(y_test, pred)

print(model.named_steps["lasso"].alpha_)
print(rmse, mae, r2)

library(glmnet)

df <- read.csv("dataset.csv", stringsAsFactors = TRUE)

formula <- G3 ~ G1 + G2 + studytime + failures +
  absences + age + Medu + Fedu +
  school + sex + address + famsize

x <- model.matrix(formula, data = df)[, -1]
y <- df$G3

set.seed(42)
cv_fit <- cv.glmnet(
  x = x,
  y = y,
  alpha = 1,
  nfolds = 5,
  standardize = TRUE,
  family = "gaussian"
)

lambda_min <- cv_fit$lambda.min
lambda_1se <- cv_fit$lambda.1se

coef_min <- coef(cv_fit, s = "lambda.min")
coef_1se <- coef(cv_fit, s = "lambda.1se")

pred_min <- as.numeric(
  predict(cv_fit, newx = x, s = "lambda.min")
)

rmse <- sqrt(mean((y - pred_min)^2))
mae <- mean(abs(y - pred_min))
r2 <- 1 - sum((y - pred_min)^2) / sum((y - mean(y))^2)

print(lambda_min)
print(lambda_1se)
print(coef_min)
print(c(rmse = rmse, mae = mae, r_squared = r2))

* Prepare and save the analysis dataset.
GET DATA
 /TYPE=TXT
 /FILE='D:\DATA ANALYSIS\H Regression Tests and Models\The L1 model\dataset.csv'
 /ENCODING='UTF8'
 /DELCASE=LINE
 /DELIMITERS=","
 /ARRANGEMENT=DELIMITED
 /FIRSTCASE=2
 /IMPORTCASE=ALL.

SAVE OUTFILE=
 'D:\DATA ANALYSIS\H Regression Tests and Models\The model\SPSS_Output\sav\Lasso-Regression-data.sav'.

* Use BEGIN PROGRAM PYTHON to run a compatible L1 workflow
  when the required Python packages are available.

OUTPUT SAVE
 /OUTFILE=
 'D:\DATA ANALYSIS\H Regression Tests and Models\Lasso\SPSS_Output\spv\Lasso-Regression-SPSS-Output.spv'.

OUTPUT EXPORT
 /CONTENTS EXPORT=ALL LAYERS=PRINTSETTING MODELVIEWS=PRINTSETTING
 /PDF DOCUMENTFILE=
 'D:\DATA ANALYSIS\H Regression Tests and Models\The penalized model\SPSS_Output\pdf\Lasso-Regression-SPSS-Output.pdf'.

Predicted Y:
=Intercept + Beta_X1*X1_Standardized + Beta_X2*X2_Standardized

Residual:
=Observed_Y-Predicted_Y

Squared error:
=Residual^2

SSE:
=SUM(Squared_Error_Range)

L1 norm:
=ABS(Beta_X1)+ABS(Beta_X2)+...

Penalized objective:
=SSE + Lambda*L1_Norm

RMSE:
=SQRT(AVERAGE(Squared_Error_Range))

Selected predictor:
=IF(ABS(Coefficient)>0,"Selected","Shrunk to zero")

• Lasso accepts systematic shrinkage bias so that estimated coefficients can vary less from sample to sample.
• When ordinary coefficients are noisy, a small amount of bias can improve new-case prediction.
• The correct penalty depends on validation evidence rather than a universal alpha value.

• An irrelevant predictor tends to receive a coefficient near zero across the penalty path.
• At the selected penalty, The L1 model can remove the predictor completely.
• Removal should still be checked across resamples because one sample can make a weak variable appear useful.

• The penalty must be selected for a clearly defined outcome and future-use setting.
• A model tuned for G3 prediction cannot automatically be reused for pass/fail classification.
• The loss function and evaluation metrics must match the prediction target.

• A sparse active set is easier to describe than a model containing every available variable.
• Shrinkage complicates direct coefficient inference, so interpretability gains are mainly structural and predictive.
• Report the selected variables together with the penalty and validation design.

• A complex regularized workflow should outperform or simplify a reasonable baseline.
• The article compares The penalized model with OLS and Ridge using the same encoded candidates.
• The small Python error advantage supports the sparse model, but repeated validation remains necessary.

• The intercept is usually not penalized.
• Centering and standardization allow the intercept to represent the expected outcome near average numeric predictor values and reference categories.
• The intercept should be transformed back appropriately when presenting predictions in original units.

• The preprocessing pipeline standardizes predictors but leaves G3 in grade units.
• Predictions therefore remain interpretable on the 0–19 grade scale.
• If the outcome were transformed, inverse transformation would be required before calculating practical errors.

• Audit the exact input columns, reference categories, active coefficients and prediction rows.
• Recalculate RMSE, MAE and R² from exported observed and predicted values.
• A reproducible audit makes Lasso Regression results easier to verify across software.

• The L1 penalty deliberately pulls coefficients toward zero, so the estimates are biased relative to OLS.
• The potential benefit is lower variance, better prediction and a smaller active set.
• A coefficient should be interpreted as a penalized prediction weight at the selected penalty.

• Correlated predictors compete to explain similar variation.
• The model may select one member of a correlated group and shrink another to zero.
• Selection can therefore be unstable even when prediction remains stable; compare with Elastic Net.

• The L1 penalty is applied to coefficient magnitude.
• Without scaling, predictor units affect how expensive a coefficient is under the penalty.
• Fit scaling inside training folds to avoid information leakage.

• Both values control penalty strength in this article.
• Numerical values are not expected to match because software uses different objective scaling and grids.
• Report the software, function, preprocessing and selected value together.

• lambda.min targets the lowest estimated cross-validation error.
• lambda.1se chooses the strongest penalty whose error is within one standard error of the minimum.
• The one-standard-error rule often gives a simpler model with slightly worse prediction.

• Repeat cross-validation with different fold assignments.
• Record how often each predictor has a non-zero coefficient.
• Stable prediction with unstable selection should be reported honestly.

• Resample observations, refit the complete pipeline and record active predictors.
• High selection frequency supports robustness, but it is not an ordinary confidence level.
• Use cluster-aware resampling when observations are grouped.

• Ordinary OLS p-values calculated after data-driven selection ignore the selection process.
• Selective-inference or sample-splitting methods are needed for formal post-selection claims.
• For a predictive article, emphasize error, stability and coefficient direction.

• Both prior grades remain active in Python and R, indicating distinct predictive information.
• Their coefficients are conditional on each other and on the remaining active variables.
• Elastic Net can test whether grouped retention improves stability.

• G2 is temporally close to G3 and strongly predictive.
• Python gives the largest standardized coefficient to G2, and R gives it the largest active coefficient.
• Dominance in prediction does not by itself establish causation.

• At the selected penalties, their conditional predictive contribution is insufficient to justify a non-zero coefficient.
• Zero does not mean the variables have no bivariate relationship with G3.
• Selection can change under a different sample, penalty or feature set.

• Python retains Medu with a small negative standardized coefficient, while R sets it to zero at lambda.min.
• Different preprocessing, coefficient scales, grids and evaluation designs can move a weak term across the zero boundary.
• The disagreement is evidence that Medu selection is not highly stable.

• school_MS compares MS with GP, sex_M compares male with female, address_U compares urban with rural and famsize_LE3 compares smaller with larger families.
• A coefficient is conditional on all other active predictors.
• Changing the reference level changes the displayed contrast but not fitted predictions.

• Python test R² exceeds training R² in this split.
• This can occur by chance when the held-out sample is easier to predict.
• Repeated splits provide a more stable assessment than one partition.

• Use an inner loop to select alpha and an outer loop to estimate prediction performance.
• Nested cross-validation reduces optimism from tuning and evaluation on the same folds.
• Report the outer-fold mean and uncertainty for RMSE, MAE and R².

• Random folds are inappropriate when records are ordered over time or grouped by person, site or school.
• Use forward validation for time and grouped folds for clusters.
• The validation design must match the intended future prediction setting.

• Imputation must be learned inside each training fold.
• Listwise deletion can change the target population and reduce sample size.
• Record the amount and pattern of missingness before fitting The L1 model.

• Squared error gives large residuals substantial influence.
• Extreme G3 = 0 cases contribute strongly to the objective.
• Robust loss functions or sensitivity analyses can be considered when measurement is valid but heavy-tailed.

• Standard Lasso Regression is linear in the supplied features.
• Add polynomial, spline or interaction features before regularization when theory supports them.
• Apply hierarchy rules carefully so an interaction is not retained without essential component terms.

• A binary outcome requires penalized logistic regression rather than the Gaussian model used here.
• Interpret active coefficients on the log-odds scale or as odds ratios after exponentiation.
• Evaluate discrimination, calibration and classification rather than RMSE alone.

• Count outcomes require a penalized Poisson or negative-binomial framework.
• A Gaussian Lasso may predict impossible negative counts.
• Choose the outcome family and performance metric before selecting the penalty.

• Regularization is designed mainly for prediction and dimension control.
• A selected sparse equation does not automatically identify causal effects.
• Confounding, measurement error and selection bias remain study-design problems.

• A relaxed approach selects an active set and then reduces or removes shrinkage during refitting.
• It can reduce coefficient bias while keeping the selected-variable structure.
• Validation must tune both the original penalty and the relaxation amount.

• Adaptive penalties assign different weights to different coefficients.
• Initial estimates guide which variables receive stronger or weaker shrinkage.
• The method can improve selection under suitable conditions but adds another modeling stage.

• Some applications require coefficients to be non-negative.
• A positive constraint should come from domain knowledge rather than convenience.
• The current student-grade model allows both positive and negative directions.

• Multi-task methods jointly model several related continuous outcomes.
• They can encourage a shared feature set across tasks.
• The current analysis has one outcome, G3, so ordinary single-task The penalized model is appropriate.

• RMSE gives extra weight to large errors, while MAE measures typical absolute error.
• R² measures proportional improvement over the mean prediction.
• Report all three because the extreme zero-grade cases affect them differently.

• A path that remains active across a wide penalty range is generally more stable.
• Late-entering weak paths may disappear under small changes in folds.
• The path is descriptive and should not be converted into a significance test.

• The R lambda.1se model retains only G2 and G1.
• Its RMSE rises to 1.347221 and R² falls to 0.825833.
• It may still be preferred when data collection cost or interpretability dominates a modest accuracy loss.

• OLS has no shrinkage and minimizes fitted squared error.
• The model may have slightly worse training fit but better validation and fewer variables.
• Choose with held-out evidence rather than training R² alone.

• Ridge spreads weight across correlated predictors and ordinarily keeps all variables.
• The penalized model creates exact zeros and a more compact active set.
• The Python test RMSE advantage of Lasso over Ridge is small and should be checked across resamples.

• Elastic Net blends L1 selection with L2 grouping behavior.
• It is often useful when multiple correlated predictors should be retained together.
• Tune both total penalty strength and the L1-to-L2 mixing parameter.

• The current model has 649 observations and 12 encoded predictors, so dimensionality is moderate.
• Lasso Regression is still useful because it evaluates whether a smaller active set preserves prediction.
• In very high-dimensional data, validation and stability checks become even more important.

• State that the variables were shrunk to zero at the selected penalty.
• Do not write that the variables have absolutely no relationship with the outcome.
• Name the exact software and penalty rule because zero status can change across implementations.

• Save the analysis data, code, seed, folds, package versions, penalty grid and exported coefficient table.
• Preserve the train-test split before comparing methods.
• Regenerate charts and reports from scripts rather than manually editing values.