def test_normalisations_real(self): log = logging.getLogger('TestZern.test_normalisations_real') n_alpha = 6 L, K = 400, 357 # polar grid pol = RZern(n_alpha) fitAlpha = FitZern(pol, L, K) t1 = time() pol.make_pol_grid(fitAlpha.rho_j, fitAlpha.theta_i) t2 = time() log.debug('make pol grid {:.6f}'.format(t2 - t1)) # cartesian grid cart = RZern(n_alpha) dd = np.linspace(-1.0, 1.0, max(L, K)) xx, yy = np.meshgrid(dd, dd) t1 = time() cart.make_cart_grid(xx, yy) t2 = time() log.debug('make cart grid {:.6f}'.format(t2 - t1)) smap = np.isfinite(cart.eval_grid(np.zeros(cart.nk))) scale = (1.0/np.sum(smap)) log.debug('') log.debug('{} modes, {} x {} grid'.format(n_alpha, L, K)) for i in range(pol.nk): a = np.zeros(pol.nk) a[i] = 1.0 Phi_a = cart.eval_grid(a) for j in range(pol.nk): b = np.zeros(pol.nk) b[j] = 1.0 Phi_b = cart.eval_grid(b) ip = scale*np.sum(Phi_a[smap]*Phi_b[smap]) if i == j: eip = 1.0 else: eip = 0.0 iperr = abs(ip - eip) log.debug('<{:02},{:02}> = {:+e} {:+e}'.format( i + 1, j + 1, ip, iperr)) self.assertTrue(iperr < self.max_ip_err)
def reconstruct(c1, L, K, n=8): from zernike import RZern cart = RZern(n) ddx = np.linspace(-1.0, 1.0, K) ddy = np.linspace(-1.0, 1.0, L) xv, yv = np.meshgrid(ddx, ddy) cart.make_cart_grid(xv, yv) return cart.eval_grid(c1[0:cart.nk], matrix=True)
def coeff(img, n=8): from zernike import RZern cart = RZern(n) L, K = img.shape ddx = np.linspace(-1.0, 1.0, K) ddy = np.linspace(-1.0, 1.0, L) xv, yv = np.meshgrid(ddx, ddy) cart.make_cart_grid(xv, yv) c1 = cart.fit_cart_grid(img)[0] return c1, L, K
def make_names(n): r = RZern(n) ntab = r.ntab mtab = r.mtab nolls = [] names = [] nms = [] for i in range(r.nk): j = i + 1 n = ntab[i] m = mtab[i] names.append(default_name(j, ntab[i], mtab[i])) nolls.append(j) nms.append([int(n), int(m)]) return names, nolls, nms
def phase_Zernike(self, Plot=True, Save=False): SLMRes = np.min([self.SLMResX, self.SLMResY]) apertureD = int(round(self.aperture_radius / self.pixelpitch * 2)) Zmatrix_size = np.min([SLMRes, apertureD]) r0 = self.pixelpitch * Zmatrix_size / 2 r0mm = r0 * 1e3 cart = RZern(6) ddx = np.linspace(-1.0, 1.0, Zmatrix_size) ddy = np.linspace(-1.0, 1.0, Zmatrix_size) xv, yv = np.meshgrid(ddx, ddy) cart.make_cart_grid(xv, yv) c = np.zeros(cart.nk) c[[self.ind_Zernike]] = 1 Phi = cart.eval_grid(c, matrix=True) # change all nan values in Phi matrix to be zero where_are_NaNs = np.isnan(Phi) Phi[where_are_NaNs] = 0 Phi_norm = Phi n = cart.ntab[self.ind_Zernike] m = cart.mtab[self.ind_Zernike] zernike_str = f"Radial: {n}, Angular: {m}" print(zernike_str) # Launch the Zernike phase pattern to SLM screen SLM_screen_aberr = np.zeros((int(self.SLMResY), int(self.SLMResX))) col_Phi_norm = np.size(Phi_norm, axis=1) row_Phi_norm = np.size(Phi_norm, axis=0) startRow_screen = self.SLMResY / 2 - round(row_Phi_norm / 2) endRow_screen = self.SLMResY / 2 + round(row_Phi_norm / 2) startCol_screen = self.SLMResX / 2 - round(col_Phi_norm / 2) endCol_screen = self.SLMResX / 2 + round(col_Phi_norm / 2) SLM_screen_aberr[int(startRow_screen):int(endRow_screen), :][:, int(startCol_screen):int(endCol_screen)] = \ Phi_norm*self.percent if Plot: im = plt.imshow(Phi_norm, origin='lower', extent=(-r0mm, r0mm, -r0mm, r0mm)) plt.title(zernike_str) plt.colorbar(im) plt.show() if Save: np.savetxt(f"SLM_Zernike_{n}{m}_{percent}.csv", SLM_screen_aberr, delimiter=",") return SLM_screen_aberr, m, n
def test_fit_real_numpy(self): log = logging.getLogger('TestFitZern.test_fit_real_numpy') z = RZern(4) F = FitZern(z, self.L, self.K) theta_i = F.theta_i rho_j = F.rho_j c = normal(size=z.nk) Phi = [z.eval_a(c, rh, th) for rh in rho_j for th in theta_i] time1 = time() ce = F._fit_slow(Phi) time2 = time() log.debug('elapsed FIT_LIST {:.6f}'.format(time2 - time1)) time1 = time() ce2 = F.fit(np.array(Phi, order='F')) time2 = time() log.debug('elapsed FIT_NUMPY {:.6f}'.format(time2 - time1)) enorm = norm(ce2 - np.array(ce, order='F')) log.debug('enorm {:e}'.format(enorm)) self.assertTrue(enorm < self.max_enorm)
def test_fit_real(self): log = logging.getLogger('TestFitZern.test_fit_real') z = RZern(4) F = FitZern(z, self.L, self.K) theta_i = F.theta_i rho_j = F.rho_j c = normal(size=z.nk) time1 = time() Phi = [z.eval_a(c, rh, th) for rh in rho_j for th in theta_i] time2 = time() log.debug('eval Phi {:.4f}'.format(time2 - time1)) time1 = time() ce = F._fit_slow(Phi) time2 = time() log.debug('elapsed time {:.4f}'.format(time2 - time1)) err1 = norm(np.array(c) - np.array(ce)) max1 = max([abs(c[i] - ce[i]) for i in range(z.nk)]) log.debug('err1 {:e} max1 {:e}'.format(err1, max1)) self.assertTrue(err1 < self.max_fit_norm)
import matplotlib.pyplot as plt import time import os from zernike import RZern from scipy.signal import convolve from scipy.optimize import minimize_scalar from scipy import stats import pkg_resources #Theoretical FWHM: 275nm #Axial 0.89*lambda/(n-sqrt(n**2-NA**2)) #Axial 721 nm rz = RZern(8) FILE_SIGMAS = pkg_resources.resource_filename('psfsim', 'data/r1_50pts.npy') def distance_map(image, xc=0, yc=0): u, v = image.shape #Meshgrid usses cartesian indexing, invert of normal matrix indexing y = np.linspace(-u / 2, u / 2, u) - yc x = np.linspace(-v / 2, v / 2, v) - xc xx, yy = np.meshgrid(x, y) return np.sqrt(xx**2 + yy**2) class Simulator(): def __init__(self,
def calibrate(self, U, images, fringe, wavelength, cam_pixel_size, cam_serial='', dname='', dm_serial='', dmplot_txs=(0, 0, 0), dm_transform=SquareRoot.name, hash1='', n_radial=25, alpha=.75, lambda1=5e-3, status_cb=False): if status_cb: status_cb('Computing Zernike polynomials ...') t1 = time() nu, ns = U.shape xx, yy, shape = fringe.get_unit_aperture() assert (xx.shape == shape) assert (yy.shape == shape) cart = RZern(n_radial) cart.make_cart_grid(xx, yy) LOG.info( f'calibrate(): Computing Zernike polynomials {time() - t1:.1f}') if status_cb: status_cb('Computing masks ...') t1 = time() zfm = cart.matrix(np.isfinite(cart.ZZ[:, 0])) self.cart = cart self.zfm = zfm zfA1, zfA2, mask = self._make_zfAs() LOG.info(f'calibrate(): Computing masks {time() - t1:.1f}') # TODO remove me mask1 = np.sqrt(xx**2 + yy**2) >= 1. assert (np.allclose(mask, mask1)) assert (np.allclose(fringe.mask, mask1)) if status_cb: status_cb('Computing phases 00.00% ...') t1 = time() def make_progress(): prevts = [time()] def f(pc): t = time() dt = t - prevts[0] prevts[0] = t if dt > 1.5 or pc > 99: status_cb(f'Computing phases {pc:05.2f}% ...') return f with Pool() as p: if status_cb: chunksize = ns // (4 * cpu_count()) if chunksize < 4: chunksize = 4 phases = [] progress_fun = make_progress() for i, phi in enumerate( p.imap(PhaseExtract(fringe), [images[i, ...] for i in range(ns)], chunksize), 1): phases.append(phi) progress_fun(100 * i / ns) else: phases = p.map(PhaseExtract(fringe), [images[i, ...] for i in range(ns)]) phases = np.array(phases) inds0 = fix_principal_val(U, phases) inds1 = np.setdiff1d(np.arange(ns), inds0) assert (np.allclose(np.arange(ns), np.sort(np.hstack((inds0, inds1))))) phi0 = phases[inds0, :].mean(axis=0) z0 = lstsq(np.dot(zfA1.T, zfA1), np.dot(zfA1.T, phi0), rcond=None)[0] phases -= phi0.reshape(1, -1) LOG.info(f'calibrate(): Computing phases {time() - t1:.1f}') if status_cb: status_cb('Computing least-squares matrices ...') t1 = time() nphi = phases.shape[1] uiuiT = np.zeros((nu, nu)) phiiuiT = np.zeros((nphi, nu)) for i in inds1: uiuiT += np.dot(U[:, [i]], U[:, [i]].T) phiiuiT += np.dot(phases[[i], :].T, U[:, [i]].T) LOG.info( f'calibrate(): Computing least-squares matrices {time() - t1:.1f}') if status_cb: status_cb('Solving least-squares ...') t1 = time() A = np.dot(zfA1.T, zfA1) C = np.dot(zfA1.T, phiiuiT) B = uiuiT U1 = cholesky(A, lower=False, overwrite_a=True) Y = solve_triangular(U1, C, trans='T', lower=False) D = solve_triangular(U1, Y, trans='N', lower=False) U2 = cholesky(B, lower=False, overwrite_a=True) YT = solve_triangular(U2, D.T, trans='T', lower=False) XT = solve_triangular(U2, YT, trans='N', lower=False) H = XT.T def vaf(y, ye): return 100 * (1 - np.var(y - ye, axis=1) / np.var(y, axis=1)) mvaf = vaf(phases.T, zfA1 @ H @ U) LOG.info(f'calibrate(): Solving least-squares {time() - t1:.1f}') if status_cb: status_cb('Applying regularisation ...') t1 = time() if alpha > 0.: # weighted least squares rr = np.sqrt(xx**2 + yy**2) win = .5 * (1 + np.cos(np.pi * ((2 * rr / (alpha) - 2 / alpha + 1)))) win[rr < 1 - alpha / 2] = 1 win[rr >= 1] = 0 stds = np.zeros(nu) for i in range(nu): ind = np.where(U[i, :] == U.max())[0][0] stds[i] = np.std(phases[ind] * win[zfm]) stds -= stds.min() stds /= stds.max() assert (stds.min() == 0.) assert (stds.max() == 1.) C = np.dot(pinv(lambda1 * np.diag(1 - stds) + np.dot(H.T, H)), H.T) else: C = np.linalg.pinv(H) uflat = -np.dot(C, z0) self.fringe = fringe self.shape = shape self.H = H self.mvaf = mvaf self.phi0 = phi0 self.z0 = z0 self.uflat = uflat self.C = C self.alpha = alpha self.lambda1 = lambda1 self.wavelength = wavelength self.dm_serial = dm_serial self.dm_transform = dm_transform self.cam_pixel_size = cam_pixel_size self.cam_serial = cam_serial self.dmplot_txs = dmplot_txs self.dname = dname self.hash1 = hash1 LOG.info(f'calibrate(): Applying regularisation {time() - t1:.1f}')
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import matplotlib.pyplot as plt import numpy as np from zernike import RZern if __name__ == '__main__': plt.close('all') fs = 7 fs1 = 6 cart = RZern(6) L, K = 300, 300 ddx = np.linspace(-1.0, 1.0, K) ddy = np.linspace(-1.0, 1.0, L) xv, yv = np.meshgrid(ddx, ddy) cart.make_cart_grid(xv, yv) c = np.zeros(cart.nk) ns = np.unique(cart.ntab) fig = plt.figure(1) nradial = 6 span = 0.05 leftoff = .03 while nradial >= 0: nk = (nradial + 1) * (nradial + 2) // 2 nrows = nradial + 1 ncols = np.where(cart.ntab == nradial)[0].size
parser = argparse.ArgumentParser( description='Plot the pyramid of Zernike polynomials', formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--max-radial-order', default=6, type=int, metavar='NMAX') args = parser.parse_args() plt.close('all') fs = 7 fs1 = 6 nradial = args.max_radial_order cart = RZern(nradial) L, K = 300, 300 ddx = np.linspace(-1.0, 1.0, K) ddy = np.linspace(-1.0, 1.0, L) xv, yv = np.meshgrid(ddx, ddy) cart.make_cart_grid(xv, yv) c = np.zeros(cart.nk) ns = np.unique(cart.ntab) fig = plt.figure(1) span = 0.05 leftoff = .03 while nradial >= 0: nk = (nradial + 1) * (nradial + 2) // 2 nrows = nradial + 1
def setUp(self): self.pupil = RZern(4) self.max_enorm = 1e-9 self.max_ip_err = 5e-2
"id": range(0, len(ent)), "TriggerNo": ent["TriggerNo"], "ChannelID": ent["ChannelID"], } ) ent["Pedestal"] = pedestal ent = ent.groupby(by=["TriggerNo"]) Thres = 0.1 fipt = "{}.h5".format(basename) ipt = h5.File(fipt, "r") nt = 80 nr = 120 cart = RZern(20) amn = np.zeros((nt, nr // 2 + 1)) zo = np.concatenate(([0], range(1, nr, 2))) # zernike orders for i in range(nt): for j in zo: if i == 0 and j == 0: a00 = coef["Intercept"] elif j == 0: amn[i, j] = coef["L{}".format(i)] elif i == 0: amn[i, (j + 1) // 2] = coef["Z{}".format(j)] else: amn[i, (j + 1) // 2] = coef["Z{}_L{}".format(j, i)] zrho = cart.rhotab[zo, :]
def main_Calib(filename, output, mode, alg, basis, order, figure, verbose, offset, qt, pre, split): ''' # main program # input: radius: %+.3f, 'str' (in makefile, str is default) # path: file storage path, 'str' # fout: file output name as .h5, 'str' (.h5 not included') # cut_max: cut off of Legendre # output: the gathered result EventID, ChannelID, x, y, z ''' if pre != 'r': print('begin reading file', flush=True) EventID, ChannelID, Q, PETime, photonTime, PulseTime, dETime, x, y, z = pub.ReadFile(filename) VertexTruth = (np.vstack((x, y, z))/1e3).T if(offset): off = pub.LoadBase(offset) else: off = np.zeros_like(PMTPos[:,0]) print('total event: %d' % np.size(np.unique(EventID)), flush=True) print('begin processing legendre coeff', flush=True) # this part for the same vertex tmp = time.time() EventNo = np.size(np.unique(EventID)) PMTNo = np.size(PMTPos[:,0]) if mode == 'PE': PMTPosRep = np.tile(PMTPos, (EventNo,1)) vertex = np.repeat(VertexTruth, PMTNo, axis=0) elif mode == 'time': counts = np.bincount(EventID) counts = counts[counts!=0] PMTPosRep = PMTPos[ChannelID] vertex = np.repeat(VertexTruth, counts, axis=0) elif mode == 'combined': PMTPosRep = np.tile(PMTPos, (EventNo,1)) vertex = np.repeat(VertexTruth, PMTNo, axis=0) if basis == 'Legendre': X, cos_theta = pub.LegendreCoeff(PMTPosRep, vertex, order, Legendre=True) elif basis == 'Zernike': from zernike import RZern cos_theta = pub.LegendreCoeff(PMTPosRep, vertex, order, Legendre=False) cart = RZern(order) nk = cart.nk m = cart.mtab n = cart.ntab rho = np.linalg.norm(vertex, axis=1)/0.65 theta = np.arccos(cos_theta) X = np.zeros((rho.shape[0], nk)) for i in np.arange(nk): if not i % 5: print(f'process {i}-th event') X[:,i] = cart.Zk(i, rho, theta) X = X[:,m>=0] print(f'rank: {np.linalg.matrix_rank(X)}') print(f'use {time.time() - tmp} s') # which info should be used if mode == 'PE': y = Q elif mode == 'time': y = PulseTime elif mode == 'combined': # PulseTime = PulseTime - np.min(PulseTime) # PulseTime = (PulseTime - np.max(PulseTime)/2)/np.max(PulseTime)*2 # print(np.min(PulseTime), np.max(PulseTime)) PulseTime = (PulseTime - np.max(PulseTime)/2)/np.max(PulseTime)*2 bins = np.arange(-1, 0.05, 0.1) N = 10 # Legendre coeff x = pub.legval(bins, np.eye(N).reshape(N, N, 1)) # 1st basis Y = np.tile(x, len(np.unique(EventID))*len(np.unique(ChannelID))).T # 2nd basis X = np.repeat(X, bins.shape[0], axis=0) # output y = np.zeros((len(np.unique(EventID)), len(np.unique(ChannelID)), len(bins))) ''' basis = np.zeros((X.shape[0], X.shape[1]*Y.shape[1])) for i_index, i in enumerate(np.arange(X.shape[1])): for j_index, j in enumerate(np.arange(Y.shape[1])): total_index = i_index*Y.shape[1] + j_index if not total_index % 10: print(total_index) basis[:, total_index] = X[:,i_index]*Y[:,j_index] X = basis ''' split_index = np.unique(EventID).shape[0] for k_index, k in enumerate(np.unique(EventID)): # event begin with 1 if k_index > split_index * split: break if not k % 100: print(k) index = EventID == k CID = ChannelID[index] Pulse_t = PulseTime[index] for i in np.unique(CID): # PMT begin with 0 y[k_index, i, 1:], _ = np.histogram(Pulse_t[CID==i], bins=bins) y = np.reshape(y,(-1)) if verbose: print(f'the basis shape is {X.shape}, and the dependent variable shape is {y.shape}') if pre =='w': if split != 1: split_index = np.int(split*y.shape[0]) X = X[:split_index] Y = Y[:split_index] y = y[:split_index] import pandas as pd import pyarrow as pa import pyarrow.parquet as pq y = np.atleast_2d(y).T #data = np.hstack((X, y, np.ones_like(y))) df_X = pd.DataFrame(X) X_names = [] for i in df_X.columns: X_names.append('X' + str(i)) df_X.columns = X_names df_Y = pd.DataFrame(Y) Y_names = [] for i in df_Y.columns: Y_names.append('Y' + str(i)) df_Y.columns = Y_names df_y = pd.DataFrame(y) df_y.columns = ['output'] df = pd.concat([df_X, df_Y, df_y], axis=1) table = pa.Table.from_pandas(df) pq.write_table(table, 'test1.parquet') return if not pre: # Regression methods: if alg == 'sms': import statsmodels.api as sm if mode == 'PE': model = sm.GLM(y, X, family=sm.families.Poisson(), fit_intercept=False) result = model.fit() if verbose: print(result.summary()) AIC = result.aic coef_ = result.params std = result.bse elif mode == 'time': import pandas as pd data = pd.DataFrame(data = np.hstack((X, np.atleast_2d(y).T))) strs = 'y ~ ' start = data.keys().start stop = data.keys().stop step = data.keys().step cname = [] cname.append('X0') for i in np.arange(start+1, stop, step): if i == start + 1: strs += 'X%d ' % i elif i == stop - step: pass else: strs += ' + X%d ' % i if i == stop - step: cname.append('y') else: cname.append('X%d' % i) data.columns = cname mod = sm.formula.quantreg(strs, data[cname]) result = mod.fit(q=qt,) coef_ = result.params AIC = np.zeros_like(coef_) std = np.zeros_like(coef_) print('Waring! No AIC and std value') elif mode == 'combined': # data = pd.DataFrame(data = np.hstack((basis, np.atleast_2d(y).T))) with h5py.File(output,'w') as out: out.create_dataset('X', data = X) out.create_dataset('Y', data = y) print('begin...') model = sm.GLM(y, X, family=sm.families.Poisson()) result = model.fit() if verbose: print(result.summary()) coef_ = result.params std = result.bse AIC = result.aic if verbose: print(result.summary()) elif (alg == 'custom'): from scipy.optimize import minimize x0 = np.zeros_like(X[0]) # initial value (be careful of Zernike order) if mode == 'PE': x0[0] = 0.8 + np.log(2) # intercept is much more important result = minimize(pub.CalibPE, x0=x0, method='SLSQP', args = (y, PMTPos, X)) elif mode == 'time': x0[0] = np.mean(y) qt = 0.1 ts = 2.6 result = minimize(pub.CalibTime, x0=x0, method='SLSQP', args = (np.hstack((EventID, EventID)), y, X, qt, ts)) elif mode == 'combined': x0 = np.zeros_like(X[0]) x0[0] = 0.8 + np.log(2) # intercept is much more important result = minimize(pub.CalibPE, x0=x0, method='SLSQP', args = (y, PMTPos, X)) coef_ = np.array(result.x, dtype=float) if verbose: print(result.message) AIC = np.zeros_like(coef_) std = np.zeros_like(coef_) H = pub.MyHessian(result.x, pub.CalibPE, *(y, PMTPos, X)) # H = pub.MyHessian(result.x, *(Q, PMTPos, X, pub.CalibTime)) # std = 1/np.sqrt(-np.diag(np.linalg.pinv(H1))) print(coef_) # print(std) print('Waring! No AIC and std value, std is testing') elif alg == 'sk': from sklearn.linear_model import TweedieRegressor alpha = 0.001 reg = TweedieRegressor(power=1, alpha=alpha, link='log', max_iter=1000, tol=1e-6, fit_intercept=False) reg.fit(X, y) # just for point data # pred = reg.predict(X[0:30,0:cut+1]) print('coeff:\n', reg.coef_,'\n') coef_ = reg.coef_ AIC = np.zeros_like(coef_) std = np.zeros_like(coef_) print('Waring! No AIC and std value') elif alg == 'h2o': import h2o from h2o.estimators.gbm import H2OGradientBoostingEstimator from h2o.estimators.glm import H2OGeneralizedLinearEstimator if mode != 'combined': y = np.atleast_2d(y).T data = np.hstack((X, y, np.ones_like(y))) h2o.init() hf = h2o.H2OFrame(data) predictors = hf.columns[0:-2] response_col = hf.columns[-2] if mode == 'PE': #offset_col = hf.columns[-1] glm_model = H2OGeneralizedLinearEstimator(family= "poisson", #offset_column = offset_col, lambda_ = 0, compute_p_values = True) glm_model.train(predictors, response_col, training_frame=hf) coef_table = glm_model._model_json['output']['coefficients_table'] coef_ = glm_model.coef() elif mode == 'time': gbm = H2OGradientBoostingEstimator(distribution="quantile", seed = 1234, stopping_metric = "mse", stopping_tolerance = 1e-4) gbm.train(x = predictors, y = response_col, training_frame = hf) breakpoint() print(gbm) exit() elif mode == 'combined': y = np.atleast_2d(y).T data = np.hstack((X, Y, y, np.ones_like(y))) h2o.init() hf = h2o.H2OFrame(data) predictors = hf.columns[0:-2] response_col = hf.columns[-2] if verbose: print(coef_) if basis == 'Zernike': print(f'Regession coef shape is f{np.array(coef_).shape}, Zernike shape is {nk}') coef_ = coef_table['coefficients'] std = coef_table['std_error'] AIC = glm_model.aic() h2o.cluster().shutdown() elif pre == 'r': import h2o from h2o.estimators.gbm import H2OGradientBoostingEstimator from h2o.estimators.glm import H2OGeneralizedLinearEstimator h2o.init() hf = h2o.import_file("electron-1.parquet") pairs = [] for i in hf.columns: for j in hf.columns: if (i.startswith('Z') and j.startswith('L')): if ((i!='X0') and (j != 'Y0')): pairs.append((i,j)) predictors = hf.columns[2:] response_col = hf.columns[0] print(predictors) print(response_col) print(pairs) if mode == 'PE': #offset_col = hf.columns[-1] glm_model = H2OGeneralizedLinearEstimator(family= "poisson", #offset_column = offset_col, lambda_ = 0, compute_p_values = True) glm_model.train(predictors, response_col, training_frame=hf) elif mode == 'combined': #offset_col = hf.columns[-1] glm_model = H2OGeneralizedLinearEstimator(family= "poisson", #offset_column = offset_col, interaction_pairs=pairs, lambda_ = 0, #remove_collinear_columns = True, compute_p_values = True) glm_model.train(predictors, response_col, training_frame=hf) breakpoint() coef_table = glm_model._model_json['output']['coefficients_table'] coef_ = coef_table['coefficients'] std = coef_table['std_error'] AIC = glm_model.aic() print(f'Regession coef is f{np.array(coef_)}') if (figure=='ON'): import matplotlib.pyplot as plt L, K = 500, 500 ddx = np.linspace(-1.0, 1.0, K) ddy = np.linspace(-1.0, 1.0, L) xv, yv = np.meshgrid(ddx, ddy) cart.make_cart_grid(xv, yv) # normal scale # im = plt.imshow(np.exp(cart.eval_grid(np.array(coef_), matrix=True)), origin='lower', extent=(-1, 1, -1, 1)) # log scale im = plt.imshow(cart.eval_grid(np.array(coef_), matrix=True), origin='lower', extent=(-1, 1, -1, 1)) plt.colorbar() plt.savefig('test.png') else: print('error regression algorithm') with h5py.File(output,'w') as out: out.create_dataset('coeff' + str(order), data = coef_) out.create_dataset('std' + str(order), data = std) out.create_dataset('AIC' + str(order), data = AIC)
def __init__(self, wavelength, n_radial, z0=None, callback=None, pars={}, parent=None): super().__init__(parent=parent) self.log = logging.getLogger(self.__class__.__name__) self.pars = {**deepcopy(self.def_pars), **deepcopy(pars)} self.units = 'rad' self.status = None self.mul = 1.0 self.figphi = None self.ax = None self.im = None self.cb = None self.shape = (128, 128) self.P = 1 self.rzern = RZern(n_radial) dd = np.linspace(-1, 1, self.shape[0]) xv, yv = np.meshgrid(dd, dd) self.rzern.make_cart_grid(xv, yv) self.rad_to_nm = wavelength / (2 * np.pi) self.callback = callback self.zernike_rows = [] if z0 is None: self.z = np.zeros(self.rzern.nk) else: self.z = z0.copy() assert (self.rzern.nk == self.z.size) group_phase = QGroupBox('phase') lay_phase = QGridLayout() group_phase.setLayout(lay_phase) self.figphi = FigureCanvas(Figure(figsize=(2, 2))) self.ax = self.figphi.figure.add_subplot(1, 1, 1) phi = self.rzern.matrix(self.rzern.eval_grid(np.dot(self.P, self.z))) self.im = self.ax.imshow(phi, origin='lower') self.cb = self.figphi.figure.colorbar(self.im) self.cb.locator = ticker.MaxNLocator(nbins=5) self.cb.update_ticks() self.ax.axis('off') self.status = QLabel('') lay_phase.addWidget(self.figphi, 0, 0) lay_phase.addWidget(self.status, 1, 0) def nmodes(): return min(self.pars['shown_modes'], self.rzern.nk) bot = QGroupBox('Zernike') lay_zern = QGridLayout() bot.setLayout(lay_zern) labzm = QLabel('shown modes') lezm = QLineEdit(str(nmodes())) lezm.setMaximumWidth(50) lezmval = MyQIntValidator(1, self.rzern.nk) lezmval.setFixup(nmodes()) lezm.setValidator(lezmval) brad = QCheckBox('rad') brad.setChecked(True) breset = QPushButton('reset') lay_zern.addWidget(labzm, 0, 0) lay_zern.addWidget(lezm, 0, 1) lay_zern.addWidget(brad, 0, 2) lay_zern.addWidget(breset, 0, 3) scroll = QScrollArea() lay_zern.addWidget(scroll, 1, 0, 1, 5) scroll.setWidget(QWidget()) scrollLayout = QGridLayout(scroll.widget()) scroll.setWidgetResizable(True) def make_hand_slider(ind): def f(r): self.z[ind] = r self.update_phi_plot() return f def make_hand_lab(le, i): def f(): self.pars['zernike_labels'][str(i)] = le.text() return f def default_zernike_name(i, n, m): if i == 1: return 'piston' elif i == 2: return 'tip' elif i == 3: return 'tilt' elif i == 4: return 'defocus' elif m == 0: return 'spherical' elif abs(m) == 1: return 'coma' elif abs(m) == 2: return 'astigmatism' elif abs(m) == 3: return 'trefoil' elif abs(m) == 4: return 'quadrafoil' elif abs(m) == 5: return 'pentafoil' else: return '' def make_update_zernike_rows(): def f(mynk=None): if mynk is None: mynk = len(self.zernike_rows) ntab = self.rzern.ntab mtab = self.rzern.mtab if len(self.zernike_rows) < mynk: for i in range(len(self.zernike_rows), mynk): lab = QLabel( f'Z<sub>{i + 1}</sub> ' + f'Z<sub>{ntab[i]}</sub><sup>{mtab[i]}</sup>') slider = RelSlider(self.z[i], make_hand_slider(i)) if str(i) in self.pars['zernike_labels'].keys(): zname = self.pars['zernike_labels'][str(i)] else: zname = default_zernike_name( i + 1, ntab[i], mtab[i]) self.pars['zernike_labels'][str(i)] = zname lbn = QLineEdit(zname) lbn.setMaximumWidth(120) hand_lab = make_hand_lab(lbn, i) lbn.editingFinished.connect(hand_lab) scrollLayout.addWidget(lab, i, 0) scrollLayout.addWidget(lbn, i, 1) slider.add_to_layout(scrollLayout, i, 2) self.zernike_rows.append((lab, slider, lbn, hand_lab)) assert (len(self.zernike_rows) == mynk) elif len(self.zernike_rows) > mynk: for i in range(len(self.zernike_rows) - 1, mynk - 1, -1): lab, slider, lbn, hand_lab = self.zernike_rows.pop() scrollLayout.removeWidget(lab) slider.remove_from_layout(scrollLayout) scrollLayout.removeWidget(lbn) lbn.editingFinished.disconnect(hand_lab) lab.setParent(None) lbn.setParent(None) assert (len(self.zernike_rows) == mynk) return f self.update_zernike_rows = make_update_zernike_rows() def reset_fun(): self.z *= 0. self.update_gui_controls() self.update_phi_plot() def change_nmodes(): try: ival = int(lezm.text()) assert (ival > 0) assert (ival <= self.rzern.nk) except Exception: lezm.setText(str(len(self.zernike_rows))) return if ival != len(self.zernike_rows): self.update_zernike_rows(ival) self.update_phi_plot() lezm.setText(str(len(self.zernike_rows))) def f2(): def f(b): if b: self.units = 'rad' self.mul = 1.0 else: self.units = 'nm' self.mul = self.rad_to_nm self.update_phi_plot() return f self.update_zernike_rows(nmodes()) brad.stateChanged.connect(f2()) breset.clicked.connect(reset_fun) lezm.editingFinished.connect(change_nmodes) splitv = QSplitter(Qt.Vertical) top = QSplitter(Qt.Horizontal) top.addWidget(group_phase) splitv.addWidget(top) splitv.addWidget(bot) self.top = top self.bot = bot l1 = QGridLayout() l1.addWidget(splitv) self.setLayout(l1) self.lezm = lezm