Why I am getting bad result for the hypertuning parameters I am trying to learn machine learning with 3 very common datasets (Boston Housing Price, Red Wine Quality, and Bike). I am using 3 ML models (LinReg, Lasso, and Ridge). The LinReg is the default of the Scikit-learn but for Lasso and Ridge, I am doing the hyper tuning.
I have 3 accuracy metrics (MAE, MSE, R2). The overall accuracy is given below
Dataset     Model       MAE         MSE         R2
House       LinReg      2.96        19.60       0.74
House       Lasso       4.58        47.44       0.39
House       Ridge       5.39        65.25       0.16

Dataset     Model       MAE         MSE         R2
Wine        LinReg      0.50        0.42        0.35
Wine        Lasso       0.68        0.65        -0.0008   
Wine        Ridge       0.66        0.62        0.05

Dataset     Model       MAE         MSE             R2
Bike        LinReg      106.56      20812.63        0.37
Bike        Lasso       118.21      25732.92        0.23
Bike        Ridge       136.31      31186.12        0.07    

You can see, the MAE and MSE are always high for the Lasso and Ridge than the LinReg.  Even, I am getting negative R2 for the Wine dataset and Lasso model.
I did very basic data pre-processing and mostly not any feature engineering. As they are very basic datasets.
I am using Optuna for hypertuning. At the time of hypertuning, I am doing 5 fold cross-validation, neg_mean_squared_error as scoring function and set direction="minimize".
For the Lasso and Ridge T am tuning only alpha and the ranges in between 1e-7, 1e2.
def lasso_objective(X_train, y_train, kfolds) -> Callable[[Trial], float]:
    def objective(trial: Trial) -> float:
        args: Dict = dict(
            alpha=trial.suggest_float("alpha", 1e-7, 1e2), 
        )
        estimator = Lasso(**args)
        scores = cross_validate(
            estimator, X=X_train, y=y_train, scoring="neg_mean_squared_error", cv=cv_method, n_jobs=-1
        )
        return float(np.mean(scores["test_score"]))

    return objective


def tune(objective):
    study = optuna.create_study(direction="minimize")
    study.optimize(objective, n_trials=200)
    params = study.best_params
    best_score = study.best_value
    return params

I am supposed to get better results for the Lasso and Ridge (as I am doing tuning here). Could you tell me why I am getting bad MAE and MSE for them? What should I do to get better results for them?

TL;DR -- The code in the question maximizes model misfit because it uses "minimize" in conjunction with neg_mean_squared_error. The correct usage is "maximize" in conjunction with "neg_mean_squared_error". We know this because the sklearn documentation says so, and also because we can demonstrate it with a simple script.
In every machine learning problem, the task is to minimize the error. One way to measure error in regression is to take the square of the difference between the observed data and the model's predictions, i.e. minimizing $(y - \hat{y})^2$.
On the other hand, the package sklearn adopted the convention of maximizing a "score". In skelarn's parlance, a "score" is an objective function that you want to maximize. From the documentation:

For the most common use cases, you can designate a scorer object with the scoring parameter; the table below shows all possible values. All scorer objects follow the convention that higher return values are better than lower return values. Thus metrics which measure the distance between the model and the data, like metrics.mean_squared_error, are available as neg_mean_squared_error which return the negated value of the metric.

We can verify that sklearn works as described in the documentation with a simple script.
from sklearn.datasets import load_boston
from sklearn.linear_model import Lasso
from sklearn.model_selection import cross_validate

X, y = load_boston(return_X_y=True)

lasso = Lasso(random_state=0, max_iter=10000)

foo = cross_validate(lasso, X=X,y=y,scoring="neg_mean_squared_error")
print((foo["test_score"] < 0.0).all())

Which prints True. This shows that the return from cross_validate with "neg_mean_squared_error" must be the negative of the square error (because squaring a real number is non-negative). If you negate the function that you're minimizing, the minimization  transforms into a maximization. Therefore, the code in the question is maximizing model misfit.
