pathos Pool can't find dynamically generated log function about pathos HOT 2 CLOSED

import time
import math
import os
import sys
import numpy as np
import sympy as sym
from sympy.stats import Normal, density, E, std, cdf, skewness
from sympy import lambdify
from scipy.optimize import minimize
from pathos.pools import ProcessPool as Pool
import pathos

#The following creats the log-likelihood function for 10 gaussian observations.
CS1_Onsets = np.array([11.65239205, 23.67586247, 31.96652543, 40.59708088, 48.44196047, 57.50153782, 68.16787918, 76.90944557, 88.71767575, 99.527949  ])
CS_Wait_Times = np.array(CS1_Onsets[0]) # This takes care of the fact that the first observation cannot be obtained by differencing.
CS_Wait_Times = np.append(CS_Wait_Times,np.diff(CS1_Onsets))
del CS1_Onsets
u_CS = sym.Symbol('u_CS',positive=True)
var_CS = sym.Symbol('var_CS',positive=True)
x_CS = sym.Symbol('x_CS',positive=True)
Gaussian_CS = density(Normal("x_CS", u_CS, var_CS**(1/2)))
log_likelihood = 0
#Compute log-likelihood:
for i in range(0,len(CS_Wait_Times),1):
    log_likelihood = log_likelihood + sym.log(Gaussian_CS(CS_Wait_Times[i]))
#########################################          Optimising the log-likelihood function        #####################################
Neg_log_likelihood = -1*log_likelihood
del log_likelihood
Neg_Score = [sym.diff(Neg_log_likelihood,u_CS),sym.diff(Neg_log_likelihood,var_CS)]
##The following implements the optimisation
bounds = [(0.0000000001,86400),(0.0000000001,86400)]  #u_CS, var_CS,u_CS_US_Int,var_CS_US_Int,p_US
options = {"maxiter":400}
Results = [] #Store the results for different starting points.
Initial_Parameter_Estimates = [(1,1),(10,10),(100,100),(1000,1000),(10000,10000),(8,1),(80,10),(800,100),(8000,1000),(80000,10000)]
start_time = time.perf_counter()
Objective = lambdify([(u_CS, var_CS)], Neg_log_likelihood,'mpmath') #This gives the negative log-likelihood in the desired form:
Gradient = lambdify([(u_CS, var_CS)], Neg_Score,'mpmath')

##Parallel Version - The following doesnt work.
def MINI(start_loc):
    import math
    import numpy as np
    import sympy as sym
    from sympy.stats import Normal, density, E, std, cdf, skewness
    from sympy import lambdify
    from scipy.optimize import minimize
    from sympy.stats import Normal, density, E, std, cdf, skewness
    fun = Objective
    x0 = start_loc
    method = 'SLSQP'
    jac = Gradient
    bounds = [(0.0000000001, 86400), (0.0000000001, 86400)]
    options = {"maxiter": 400}
    result = minimize(fun=fun, x0=x0, method='SLSQP', jac=jac, bounds=bounds, options=options)
    return result


if __name__ == '__main__':

    pool = Pool()

    from pathos.helpers import freeze_support
    freeze_support()
    start_time = time.perf_counter()
    RESULTS = pool.map(MINI,Initial_Parameter_Estimates)
    r = list(map(MINI, Initial_Parameter_Estimates))
    finish = time.perf_counter()
    Running_parallel = finish - start_time
    print('Running time of parallel execution is:',Running_parallel)
    # cleanup
    pool.close()
    pool.join()
    pool.clear()