Convex optimization with bounds for the parameters in Python

Question

For a project that I am currently working on, I need to optimize a convex problem. As can be read only there are different optimization tools in python in order to obtain the solution of a convex problem (e.g. scipy, CVXPY). However, by implementing these minimization algorithms I keep obtaining that success = 'False'.

Convex problem

To clearify: \beta = (\beta_0,\beta_1) is the optimization variable and \beta_k = (\beta_{k0},\beta{k1}) are just constants.

My code would look as follows:

import pandas as pd
import numpy as np
import math
from scipy import optimize
import matplotlib.pyplot as plt
from scipy.optimize import fmin
from scipy.optimize import Bounds

t = np.array([1,2,4,6,9,13])
y = np.array([3,4,6,10,17,25])

beta_k = [4.0,0.0]

def h_0():
    test_h_0 = 0
    for i in range(len(y)):
        partial = 2*y[i]*beta_k[0]*np.exp(beta_k[1]*t[i]) + 20*t[i]*np.exp(4*t[i])*(beta_k[0]**2)
        test_h_0 += partial        
    return test_h_0
    
def partial_h_0_1(beta):
    test_h_0_1 = 0
    for i in range(len(y)):
        partial = (2*y[i]*np.exp(beta_k[1]*t[i]) + 40*t[i]*beta_k[0]*np.exp(4*t[i]))*(beta[0]-beta_k[0])
        test_h_0_1 += partial
    return test_h_0_1

def partial_h_0_2(beta):
    test_h_0_2 = 0
    for i in range(len(y)):
        partial = (2*t[i]*y[i]*beta_k[0]*np.exp(beta_k[1]*t[i]))*(beta[1]-beta_k[1])
        test_h_0_2 += partial
    return test_h_0_2
        
def h_0_hat(beta):
    return h_0() + partial_h_0_1(beta) + partial_h_0_2(beta)
        
def g_0(beta):
    test_g_0 = 0
    for i in range(len(y)):
        partial = (beta[0]**2)*np.exp(2*beta[1]*t[i]) + 20*t[i]*np.exp(4*t[i])*(beta[0]**2) + (y[i]**2)
        test_g_0 += partial
    return test_g_0
        
def f_0(beta):
    return g_0(beta) - h_0_hat(beta)


bnds = Bounds([1,-np.inf],[10,2])
cons = ({'type': 'ineq',
             'fun': lambda beta: -beta[0] + 10.0},
            {'type': 'ineq',
             'fun': lambda beta: beta[0] - 1.0},
            {'type': 'ineq',
             'fun': lambda beta: -beta[1]+2.0})

test = optimize.minimize(f_0, x0=[0.0,0.0], method='trust-constr', constraints= cons)
beta = test.x