def print_function(params, iter, gradient):
""" Print the error at every iteration """
if iter % 10 == 0:
print(
"Total Error:",
np.sum(
np.absolute(neural_net_predict(params, inputs) - targets)))
def print_function(params, iter, gradient):
plot_inputs = np.linspace(-8, 8, num=400)
outputs = neural_net_predict(params, np.expand_dims(plot_inputs, 1))
# Plot data and functions.
plt.cla()
plt.title('Overfitting test with L2_reg = %f' % L2_reg)
ax.set_xlabel("Possible Inputs")
ax.set_ylabel("Neural Network Outputs")
ax.plot(inputs, targets, 'bx', label='Train Data')
ax.plot(testinputs, testtargets, 'bo', label='Test Data')
ax.plot(plot_inputs, outputs)
ax.legend()
ax.set_ylim([-2, 3])
# Plot the cost function for the test
testcost = np.sum(
(neural_net_predict(params, testinputs) - testtargets)**2)
traincost = np.sum((neural_net_predict(params, inputs) - targets)**2)
diff = np.absolute(testcost - traincost)
testcostlist.append(testcost)
traincostlist.append(traincost)
iterlist.append(iter)
ax2.plot(iterlist, testcostlist, 'r-', label='Test Cost')
ax2.plot(iterlist, traincostlist, 'g-', label='Train Cost')
ax2.set_xlabel('Number of Iterations')
ax2.set_ylabel('Error in Estimation or Cost')
ax2.set_xlim([0, 50])
if iter == 0:
ax2.legend()
plt.draw()
#plt.savefig(str(iter) + '.jpg')
plt.pause(1.0 / 60.0)
def hess_lnpost(ws,fdensity,alpha,sig):
print('hess')
#print(ws);
mo = np.exp(-4.);
#hval = hfunc(ws);
ws = ws.reshape((n_grid,n_grid));
#calc l1
lsis = np.array([-1*np.sum(psi(index)**2)/sig_noise**2 for (index,w) in np.ndenumerate(ws)]);
lsis = lsis.reshape((n_grid,n_grid));
l1 = lsis#*np.sum((Psi(ws)-data)/2/sig_noise**2);
xsi = (1.-fdensity ) * gaussian(np.log(ws),loc=np.log(mo), scale=sig)/ws + fdensity*(ws**alpha /w_norm)
dxsi = -1*gaussian(np.log(ws),loc=np.log(mo), scale=sig)*(1.-fdensity)/ws**2 - (1.-fdensity)*np.log(ws/mo)*np.exp(-np.log(ws/mo)**2 /2/sig**2)/np.sqrt(2*np.pi)/ws**2 /sig**3 + fdensity*alpha*ws**(alpha-1) /w_norm;
dxsi_st = -1*gaussian(np.log(ws),loc=np.log(mo), scale=sig)*(1.-fdensity)/ws**2 - (1.-fdensity)*np.log(ws/mo)*np.exp(-np.log(ws/mo)**2 /2/sig**2)/np.sqrt(2*np.pi)/ws**2 /sig**3;
ddxsi_st = -1*dxsi_st/ws - dxsi_st*np.log(ws/mo)/ws /sig**2 -(1.-fdensity)*(1/np.sqrt(2*np.pi)/sig)*np.exp(-np.log(ws/mo)**2 /2/sig**2)*(1/sig**2 - np.log(ws/mo)/sig**2 -1)/ ws**3;
ddxsi = ddxsi_st + fdensity*alpha*(alpha-1)*ws**(alpha-2) /w_norm ;
l2 = -1*(dxsi/xsi)**2 + ddxsi/np.absolute(xsi);
l_tot = l1+l2;
#those are the diagonal terms, now need to build off diagonal
hess_m = np.zeros((n_grid**2,n_grid**2));
np.fill_diagonal(hess_m,l_tot);
'''
for i in range(0,n_grid**2):
for j in range(i+1,n_grid**2):
ind1 = (int(i/n_grid),i%n_grid);
ind2 = (int(j/n_grid),j%n_grid);
hess_m[i,j] = -1*np.sum(psi(ind1)*psi(ind2))/sig_noise**2;
hess_m = symmetrize(hess_m);
'''
print('hess fin');
#print(l_tot);
#print('new it');
#print(np.average(hval[0][:][:]-hess_m));
return -1*hess_m;
def grad_k(ws, fdensity, alpha, sig, psf_k):
print('grad_k begin')
mo = np.exp(-4.)
ws = real_to_complex(ws)
ws = ws.reshape((n_grid, n_grid))
#wk = ws;
ws = np.real(fft.ifft2(ws))
l1 = -1 * fft.ifft2((fft.ifft2(fft.fft2(ws) * fft.fft2(psf)) - data) /
sig_noise**2) * psf_k
'''
l1_og = fft.ifft2((Psi(ws) - data)/sig_noise**2)*psf_k;
l1_other = fft.ifft2((fft.fft2(fft.ifft2(ws)*fft.ifft2(psf)) - data)/sig_noise**2)*psf_k;
print('diff is:');
print(l1 - l1_other);
print(l1-l1_og);
'''
#print(l1-l1_other)
l1 = l1.flatten()
xsi = (1. - fdensity) * gaussian(np.log(ws), loc=np.log(
mo), scale=sig) / ws + fdensity * (ws**alpha / w_norm)
l2 = -1 * gaussian(np.log(ws), loc=np.log(mo), scale=sig) * (
1. - fdensity) / ws**2 - (1. - fdensity) * np.log(ws / mo) * np.exp(
-np.log(ws / mo)**2 / 2 / sig**2) / np.sqrt(
2 * np.pi) / ws**2 / sig**3 + fdensity * alpha * ws**(
alpha - 1) / w_norm
l2 = l2 / np.absolute(xsi)
l2 = fft.ifft2(l2).flatten()
l_tot = l1 + l2
#return l1,l2;
l_tot = complex_to_real(l_tot)
#print('grad is');
#print(l_tot);
return l_tot
def delta_for_minimal_r_0(deltaStart, NAtoms, kd, g1d, gprime, gm, Deltac,
Omega):
res = minimize(lambda x: np.absolute(
r_0(x[0], NAtoms, kd, g1d, gprime, gm, Deltac, Omega)),
deltaStart,
method='Nelder-Mead')
return res.x[0]
def _evaluate(self, x, out, *args, **kwargs):
f = -anp.sqrt(self.n_var)**self.n_var * anp.prod(x, axis=1)
# Constraints
g = anp.absolute(anp.sum(x**2, axis=1) - 1) - 1e-4
out["F"] = f
out["G"] = g
def cost(coef):
X_coef = -1 * np.matmul(X_, coef)
z = 1 / (1 + np.exp(X_coef))
epsilon = 1e-5
class1 = np.multiply(y_, np.log(z + epsilon))
class2 = np.multiply(1 - y_, np.log(1 - z + epsilon))
ans = -(1 / y_.size) * (np.sum(class1 + class2))
if self.penalty == "l1":
return ans + self.val * np.sum(np.absolute(coef))
else:
return ans + self.val * np.sum(np.square(coef))
def __init__(self, data, psf, psf_k, no_source):
self.data = np.absolute(data)
self.psf = psf
self.psf_k = psf_k
self.n_grid = len(data)
self.f_true = no_source / self.n_grid**2
self.wlim = (1, 2)
#min and max signal (given by challenge, will determine ourselves in the future)
self.sig_noise = self.getNoise()
self.norm_mean, self.norm_sig = self.getNorm()
self.xi = self.getXi()
self.res = self.run()
def find_KL(dist1, dist2):
L = len(dist1)
if L != len(dist2):
raise ValueError("Distributions must be same length")
kl = 0.0
for i in xrange(L):
#temp = dist1[i]*(np.log(dist1[i]) - np.log(dist2[i]))
if (dist1[i] != 0 and dist2[i] != 0):
#print kl
kl += dist1[i]*(np.log(dist1[i]) - np.log(dist2[i]))
#print kl
return np.absolute(kl)
def cherry_warp(wts, inputs, labels, parameters):
# hidden layer input
biased_inputs = np.subtract(inputs, wts[0])**2
# hidden layer activations
hidden_activations = np.exp(
-np.absolute(np.einsum('hif,fh -> ih', biased_inputs, wts[2])))
# output layer activations
output_activations = softmax(hidden_activations, wts, labels, parameters)
return output_activations, hidden_activations
def _evaluate(self, x, out, *args, **kwargs):
f = 3 * x[:, 0] + (10**-6) * x[:, 0]**3 + 2 * x[:, 1] + (
2 * 10**(-6)) / 3 * x[:, 1]**3
# Constraints
g1 = x[:, 2] - x[:, 3] - 0.55
g2 = x[:, 3] - x[:, 2] - 0.55
g3 = anp.absolute(
1000 * (anp.sin(-x[:, 2] - 0.25) + anp.sin(-x[:, 3] - 0.25)) +
894.8 - x[:, 0]) - 10**(-4)
g4 = anp.absolute(
1000 *
(anp.sin(x[:, 2] - 0.25) + anp.sin(x[:, 2] - x[:, 3] - 0.25)) +
894.8 - x[:, 1]) - 10**(-4)
g5 = anp.absolute(
1000 *
(anp.sin(x[:, 3] - 0.25) + anp.sin(x[:, 3] - x[:, 2] - 0.25)) +
1294.8) - 10**(-4)
out["F"] = f
out["G"] = anp.column_stack([g1, g2, g3, g4, g5])
def spectra_calculation(u):
# Transform to Fourier space
array_hat = np.real(np.fft.fft(u))
# Normalizing data
array_new = np.copy(array_hat / float(nx))
# Energy Spectrum
espec = 0.5 * np.absolute(array_new)**2
# Angle Averaging
eplot = np.zeros(nx // 2, dtype='double')
for i in range(1, nx // 2):
eplot[i] = 0.5 * (espec[i] + espec[nx - i])
return eplot
def grad_lnpost(ws,fdensity,alpha,sig):
#calculate gradient of the ln posterior
print('grad');
mo = np.exp(-4.);
ws = ws.reshape((n_grid,n_grid));
#calc l1
bsis = (Psi(ws)-data)/sig_noise**2;
lsis = ws*0;
for (index,w) in np.ndenumerate(ws):
lsis[index] = np.sum(psi(index)*bsis);
l1 = lsis#*np.sum((Psi(ws)-data)/2/sig_noise**2);
xsi = (1.-fdensity ) * gaussian(np.log(ws),loc=np.log(mo), scale=sig)/ws + fdensity*(ws**alpha /w_norm)
l2 = -1*gaussian(np.log(ws),loc=np.log(mo), scale=sig)*(1.-fdensity)/ws**2 - (1.-fdensity)*np.log(ws/mo)*np.exp(-np.log(ws/mo)**2 /2/sig**2)/np.sqrt(2*np.pi)/ws**2 /sig**3 + fdensity*alpha*ws**(alpha-1) /w_norm;
l2 = l2/np.absolute(xsi);
l_tot = l1-l2;
return l_tot.flatten();
def grad_lnpost(self,ws,fdensity,alpha,sig):
#calculate gradient of the ln posterior
print('grad');
w_norm = (self.wlim[1]**(alpha+1) - self.wlim[0]**(alpha+1))/(alpha+1); #normalization from integrating
mo = np.exp(self.norm_mean);
ws = ws.reshape((self.n_grid,self.n_grid));
#calc l1
bsis = (self.Psi(ws)-self.data)/self.sig_noise**2;
lsis = ws*0;
for (index,w) in np.ndenumerate(ws):
lsis[index] = np.sum(self.psi(index)*bsis);
l1 = lsis#*np.sum((Psi(ws)-data)/2/sig_noise**2);
xsi = (1.-fdensity ) * self.gaussian(np.log(ws),loc=np.log(mo), scale=sig)/ws + fdensity*(ws**alpha /w_norm)
l2 = -1*self.gaussian(np.log(ws),loc=np.log(mo), scale=sig)*(1.-fdensity)/ws**2 - (1.-fdensity)*np.log(ws/mo)*np.exp(-np.log(ws/mo)**2 /2/sig**2)/np.sqrt(2*np.pi)/ws**2 /sig**3 + fdensity*alpha*ws**(alpha-1) /w_norm;
l2 = l2/np.absolute(xsi);
l_tot = l1-l2;
return l_tot.flatten();
def _evaluate(self, x, out, *args, **kwargs):
l = []
for j in range(self.n_var):
l.append((j + 1) * x[:, j]**2)
sum_jx = anp.sum(anp.column_stack(l), axis=1)
a = anp.sum(anp.cos(x)**4, axis=1)
b = 2 * anp.prod(anp.cos(x)**2, axis=1)
c = (anp.sqrt(sum_jx)).flatten()
c = c + (c == 0) * 1e-20
f = -anp.absolute((a - b) / c)
# Constraints
g1 = -anp.prod(x, 1) + 0.75
g2 = anp.sum(x, axis=1) - 7.5 * self.n_var
out["F"] = f
out["G"] = anp.column_stack([g1, g2])
def sgrad_lnpost(w_all, index, fdensity, alpha, sig):
#calculate gradient of the ln posterior
mo = np.exp(-4.)
ws = w_all[index]
#calc l1
bsis = -(Psi(w_all) - data) / sig_noise**2
lsis = np.sum(bsis * psi(index))
l1 = lsis #*np.sum((Psi(ws)-data)/2/sig_noise**2);
xsi = (1. - fdensity) * gaussian(np.log(ws), loc=np.log(
mo), scale=sig) / ws + fdensity * (ws**alpha / w_norm)
l2 = -1 * gaussian(np.log(ws), loc=np.log(mo), scale=sig) * (
1. - fdensity) / ws**2 - (1. - fdensity) * np.log(ws / mo) * np.exp(
-np.log(ws / mo)**2 / 2 / sig**2) / np.sqrt(
2 * np.pi) / ws**2 / sig**3 + fdensity * alpha * ws**(
alpha - 1) / w_norm
l2 = l2 / np.absolute(xsi)
#l2 = fdensity*alpha*ws**(alpha-1) /w_norm /(fdensity*(ws**alpha /w_norm))
l_tot = l1 + l2
return -1 * l_tot
def compute_control_inputs(fc, xk, yk, thetak):
n = xk.shape[0] - 1
# import ipdb; ipdb.set_trace()
dx = xk[1:] - xk[0:-1]
dy = yk[1:] - yk[0:-1]
dk = np.array([dx, dy, np.zeros(n)]).T
dtheta = (thetak[1:] - thetak[0:-1]) / (1.0 / fc)
# vel
qk = np.array([np.cos(thetak[:-1]), np.sin(thetak[:-1]), np.zeros(n)]).T
proj_q_d = np.sum(qk * dk, axis=1)
sign_v = sign(proj_q_d)
vk = np.linalg.norm(dk, axis=1) * sign_v / (1.0 / fc)
# steering angle
phi_k = np.zeros(vk.shape)
mask = np.absolute(vk) > 1e-5
phi_k[mask] = np.arctan(wheelbase * dtheta[mask] / vk[mask])
u = np.array((vk, phi_k))
return u
def grad_lnpost(ws, fdensity, alpha, sig):
#calculate gradient of the ln posterior
mo = np.exp(-4.)
ws = ws.reshape((n_grid, n_grid))
#calc l1
bsis = -(Psi(ws) - data) / sig_noise**2
lsis = np.array(
[np.sum(bsis * psi(index)) for (index, w) in np.ndenumerate(ws)])
lsis = lsis.reshape((n_grid, n_grid))
l1 = lsis #*np.sum((Psi(ws)-data)/2/sig_noise**2);
xsi = (1. - fdensity) * gaussian(np.log(ws), loc=np.log(
mo), scale=sig) / ws + fdensity * (ws**alpha / w_norm)
l2 = -1 * gaussian(np.log(ws), loc=np.log(mo), scale=sig) * (
1. - fdensity) / ws**2 - (1. - fdensity) * np.log(ws / mo) * np.exp(
-np.log(ws / mo)**2 / 2 / sig**2) / np.sqrt(
2 * np.pi) / ws**2 / sig**3 + fdensity * alpha * ws**(
alpha - 1) / w_norm
l2 = l2 / np.absolute(xsi)
#l2 = fdensity*alpha*ws**(alpha-1) /w_norm /(fdensity*(ws**alpha /w_norm))
l_tot = l1 + l2
return -1 * l_tot.flatten()
def eig_solver(L, mode='smallest', var_percentage=0.9):
#L = ensure_matrix_is_numpy(L)
Σ, eigenVectors = np.linalg.eigh(L)
absΣ = np.absolute(Σ)
#less0 = np.sum(Σ < 0) # DONT USE, It seems to get better results if we pass all the information through at each epoch
rank_sorted = np.cumsum(absΣ) / np.sum(absΣ)
rank = np.sum(rank_sorted < var_percentage) + 1
#num_eig = np.min([less0, rank])
num_eig = rank
if mode == 'smallest':
U = eigenVectors[:, 0:num_eig]
U_λ = Σ[0:num_eig]
elif mode == 'largest':
n2 = len(Σ)
n1 = n2 - num_eig
U = eigenVectors[:, n1:n2]
U_λ = Σ[n1:n2]
else:
raise ValueError('unrecognized mode : ' + str(mode) + ' found.')
return [U, U_λ]
def _evaluate_wo_regularization(self, *params):
return np.nansum(np.absolute(self.data - self.model(*params)))
def _evaluate_w_regularization(self, *params):
return np.nansum(
np.absolute(self.data - self.model(*params[:-1])) +
params[-1] * self.regularization(*params[:-1]))
#w_true = np.abs(np.random.rand(Ndata))+1;
#true grid needs to be set up with noise
w_true_grid = np.zeros((n_grid, n_grid))
for x, y, w in zip(x_true, y_true, w_true):
w_true_grid[np.argmin(np.abs(theta_grid - x)),
np.argmin(np.abs(theta_grid - y))] = w
data = Psi(w_true_grid) + sig_noise * np.random.randn(n_grid, n_grid)
########################################################################
#now begin the actual execution
########################################################################
#now we begin the optimization
#tt0 = np.zeros(n_grid**2) +3; #begin with high uniform M
tt0 = np.absolute(np.random.randn(n_grid**2)) + 2
#tt0[1] = 0.5
#tt0[5] = 0.2
#tt0[7] = 0.1
#begin with the simple method of just minimizing
f_curr = fdensity_true
a_curr = 2
sig_delta = 0.75
'''
#afunc = Agrad.grad(lambda tt: -1*lnpost(tt,f_curr,a_curr,sig_delta));
af_like = Agrad.grad(lambda tt: -1*lnlike(tt));
af_pri = Agrad.grad(lambda tt: -1*lnprior(tt,f_curr,a_curr,sig_delta));
aval_like = af_like(tt0);
aval_pri = af_pri(tt0);
aval = aval_like+aval_pri
tt0 = tt0.reshape((n_grid,n_grid));
# plot DerL
fig, ax = plt.subplots()
ax.set(xlabel='Θ(rad)',
ylabel="dL(Θ)/dΘ (H/rad)",
title='Ρυθμός Mεταβολής Αλληλεπαγωγής dL(Θ)/dΘ')
ax.grid()
ax.plot(theta, DerL(theta))
plt.show()
# plot E(f)^2
t = np.linspace(0, 5 / f, 1000)
timestep = ((5 / f) + 1) / t.size
E_f = np.fft.fft(E(t))
E_f = np.absolute(E_f)
freq = np.fft.fftfreq(t.size, d=timestep)
fig, ax = plt.subplots()
ax.set(xlabel='f(Hz)',
ylabel='E(f)^2 ((V*s)^2)',
title='Φασματική Πυκνότητα Ενέργειας E(f)^2')
ax.grid()
ax.plot(freq, np.power(E_f, 2))
plt.show()
# fourier series coefficients with monte carlo integration, using 10000 samples
monte_time = np.linspace(0, 1 / f, 10000)
E_t = E(monte_time)
def l1_norm(params):
if isinstance(params, dict):
return np.sum(np.absolute(flatten(params)[0]))
return np.sum(np.absolute(flatten(params.value)[0]))
def trial_function(self, x_in, weights):
"""Compute custom trial function."""
return self.bc(x_in) * \
(1.0 - erf(x_in[0] / (np.sqrt(x_in[1]*4.0*self.d_v) + 1.0E-9) *
np.absolute(self.mlp.network_output(x_in, weights))))
#create coordinate grid
theta_grid = np.linspace(0., 1., n_grid) # gridding of theta (same as pixels)
#create true values - assign to grid
x_true = np.abs(np.random.rand(Ndata)) # location of sources
y_true = np.abs(np.random.rand(Ndata))
#w_true = np.abs(np.random.rand(Ndata))+1;
#true grid needs to be set up with noise
w_true_grid = np.zeros((n_grid, n_grid))
for x, y, w in zip(x_true, y_true, w_true):
w_true_grid[np.argmin(np.abs(theta_grid - x)),
np.argmin(np.abs(theta_grid - y))] = w
data = np.real(fft.ifft2(fft.fft2(w_true_grid) * fft.fft2(psf))) + np.absolute(
sig_noise * np.random.randn(n_grid, n_grid))
data3 = signal.convolve(w_true_grid, psf)
diff = int((len(data3[:, 0]) - n_grid) / 2)
data3 = data3[diff:n_grid + diff, diff:n_grid + diff]
#data = data3;
'''
fig, ax = plt.subplots(1,2)
ax[0].imshow(w_true_grid);
ax[0].set_title('True Positions')
#ax[1].imshow(data3[:-4,:-4]);
ax[1].imshow(data4);
ax[1].set_title('Observed Data')
plt.show();
'''
#create fft of psf
psf_k = fft.fft2(psf)
def lasso_cost(th, X, y, lmbd):
y_pred = anp.dot(X, th[:, None])
error_square = anp.square(y[:, None] - y_pred).sum()
lasso_error = (lmbd) * ((anp.absolute(th)).sum())
r = error_square + lasso_error
return r
def hess_k(ws, fdensity, alpha, sig, psf_k):
print('hess_k begin')
mo = np.exp(-4.)
ws = real_to_complex(ws)
ws = ws.reshape((n_grid, n_grid))
ws = np.real(fft.ifft2(ws))
#calc l1 we only get diagonals here
l1 = -1 * (psf_k**2 / sig_noise**2 / n_grid**2).flatten()
#calc l2, the hessian of the prior is messy
xsi = (1. - fdensity) * gaussian(np.log(ws), loc=np.log(
mo), scale=sig) / ws + fdensity * (ws**alpha / w_norm)
dxsi = -1 * gaussian(np.log(ws), loc=np.log(mo), scale=sig) * (
1. - fdensity) / ws**2 - (1. - fdensity) * np.log(ws / mo) * np.exp(
-np.log(ws / mo)**2 / 2 / sig**2) / np.sqrt(
2 * np.pi) / ws**2 / sig**3 + fdensity * alpha * ws**(
alpha - 1) / w_norm
dxsi_st = -1 * gaussian(np.log(ws), loc=np.log(mo), scale=sig) * (
1. - fdensity) / ws**2 - (1. - fdensity) * np.log(ws / mo) * np.exp(
-np.log(ws / mo)**2 / 2 / sig**2) / np.sqrt(
2 * np.pi) / ws**2 / sig**3
ddxsi_st = -1 * dxsi_st / ws - dxsi_st * np.log(ws / mo) / ws / sig**2 - (
1. - fdensity) * (1 / np.sqrt(2 * np.pi) / sig) * np.exp(
-np.log(ws / mo)**2 / 2 /
sig**2) * (1 / sig**2 - np.log(ws / mo) / sig**2 - 1) / ws**3
ddxsi = ddxsi_st + fdensity * alpha * (alpha - 1) * ws**(alpha -
2) / w_norm
l2 = -1 * (dxsi / xsi)**2 + ddxsi / np.absolute(xsi)
#this is the hessian of the prior wrt m_x, not m_k
l2_k = fft.ifft2(l2).flatten() / n_grid**2
#we assume that hessian of l2 is diagonal. Under assumption k = -k', then we only get the zeroth element along the diag
#lets fill the entire matrix and see whats up;
hess_m = np.zeros((n_grid**2, n_grid**2), dtype=complex)
hess_l1 = np.zeros((n_grid**2, n_grid**2), dtype=complex)
np.fill_diagonal(hess_l1, l1)
off = []
#print(l2_k[0]);
for i in range(0, n_grid**2):
for j in range(0, n_grid**2):
hess_m[i, j] = l2_k[int(np.absolute(i - j))]
#check the off diagonals to make sure they are small
if i != j:
off.append(l2_k[int(np.absolute(i - j))])
hess_m = hess_l1 + hess_m
'''
print('Sigma Real is:');
print(np.std(np.real(off)));
print('Simga Imag is:');
print(np.std(np.imag(off)));
fig, ax = plt.subplots(1,2)
ax[0].imshow(np.real(hess_m));
ax[0].set_title('Real Hessian')
#ax[1].imshow(data3[:-4,:-4]);
ax[1].imshow(np.imag(hess_m));
ax[1].set_title('Imaginary Hessian')
plt.show();
'''
l_tot = np.diagonal(hess_m)
l_minr = min(np.real(l_tot))
l_mini = min(np.imag(l_tot))
#print(l_tot-l1);
if l_minr < 0:
l_tot = l_tot - l_minr + 0.1
if l_mini < 0:
l_tot = l_tot - 1j * (l_mini + 0.1)
'''
print('diag is:');
print(l2_k[0]);
print('other is:');
print(l1);
'''
'''
hess_m = np.zeros((n_grid**2,n_grid**2));
np.fill_diagonal(hess_m,l_tot);
return hess_m;
'''
#return l1,l2_k[0];
l_tot = complex_to_real(l_tot)
#print('hess is');
#print(l_tot);
return l_tot
