def __init__(self, ecal_train=[], hcal_train=[], true_train=[], lim_min=-1, lim_max=-1, lim=-1): Calibration.__init__(self, ecal_train, hcal_train, true_train, lim) self.lim_min = lim_min self.lim_max = lim_max if lim_min == -1: ind_min = np.ones(len(self.ecal_train), dtype=bool) else: ind_min = self.ecal_train + self.hcal_train > lim_min if lim_max == -1: ind_max = np.ones(len(self.ecal_train), dtype=bool) else: ind_max = self.ecal_train + self.hcal_train < lim_max #CASE : ecal != 0 ind_0 = self.ecal_train != 0 ind = np.logical_and(ind_min, ind_max) ind = np.logical_and(ind, ind_0) X_train = [self.ecal_train[ind], self.hcal_train[ind]] X_train = np.transpose(np.matrix(X_train)) Y_train = self.true_train[ind] Y_train = np.transpose(np.matrix(Y_train)) linRegr_ecal_neq_0 = linear_model.LinearRegression() linRegr_ecal_neq_0.fit(X_train, Y_train) #CASE : ecal == 0 ind_0 = self.ecal_train == 0 ind = np.logical_and(ind_min, ind_max) ind = np.logical_and(ind, ind_0) X_train = self.hcal_train[ind] X_train = np.transpose(np.matrix(X_train)) Y_train = self.true_train[ind] Y_train = np.transpose(np.matrix(Y_train)) linRegr_ecal_eq_0 = linear_model.LinearRegression() linRegr_ecal_eq_0.fit(X_train, Y_train) self.linRegr_ecal_neq_0 = linRegr_ecal_neq_0 self.linRegr_ecal_eq_0 = linRegr_ecal_eq_0
def __init__(self, ecal_train=[], hcal_train=[], true_train=[], n_neighbors_ecal_eq_0=2000, n_neighbors_ecal_neq_0=250, algorithm='auto', lim=-1): """ Parameters ---------- ecal_train : array-like ecal value to train the calibration hcal_train : array-like hcal value to train the calibration true_train : array-like true value to train the calibration n_neighbors_ecal_eq_0: int Number of neighbors to use by default for k_neighbors queries. for ecal == 0 n_neighbors_ecal_neq_0: int Number of neighbors to use by default for k_neighbors queries. for ecal != 0 algortihm : {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, optional Algorithm used to compute the nearest neighbors: 'ball_tree' will use BallTree 'kd_tree' will use KDtree 'brute' will use a brute-force search. 'auto' will attempt to decide the most appropriate algorithm based on the values passed to fit method. lim : float to reject calibration points with ecal + hcal > lim if lim = - 1, there is no limit """ Calibration.__init__(self, ecal_train, hcal_train, true_train, lim) self.n_neighbors_ecal_eq_0 = n_neighbors_ecal_eq_0 self.n_neighbors_ecal_neq_0 = n_neighbors_ecal_neq_0 self.algorithm = algorithm #Case ecal == 0 self.neigh_ecal_eq_0 = neighbors.NearestNeighbors( n_neighbors=self.n_neighbors_ecal_eq_0, algorithm=algorithm) self.hcal_train_ecal_eq_0 = self.hcal_train[self.ecal_train == 0] self.hcal_train_ecal_eq_0_min = min(self.hcal_train_ecal_eq_0) self.true_train_ecal_eq_0 = self.true_train[self.ecal_train == 0] self.neigh_ecal_eq_0.fit( np.transpose(np.matrix(self.hcal_train_ecal_eq_0))) # Case ecal != 0 self.neigh_ecal_neq_0 = neighbors.NearestNeighbors( n_neighbors=self.n_neighbors_ecal_neq_0, algorithm=algorithm) self.ecal_train_ecal_neq_0 = self.ecal_train[self.ecal_train != 0] self.hcal_train_ecal_neq_0 = self.hcal_train[self.ecal_train != 0] self.true_train_ecal_neq_0 = self.true_train[self.ecal_train != 0] self.hcal_train_ecal_neq_0_min = min(self.hcal_train_ecal_neq_0) self.ecal_train_ecal_neq_0_min = min(self.ecal_train_ecal_neq_0) self.neigh_ecal_neq_0.fit( np.transpose( np.matrix( [self.ecal_train_ecal_neq_0, self.hcal_train_ecal_neq_0])))
def __init__(self, ecal_train=[], hcal_train=[], true_train=[], n_neighbors_ecal_eq_0=2000, n_neighbors_ecal_neq_0=250, weights='gaussian', algorithm='auto', sigma=1, lim=-1, energystep=1, kind='cubic', cut=2): """ Parameters ---------- ecal_train : array-like ecal value to train the calibration hcal_train : array-like hcal value to train the calibration true_train : array-like true value to train the calibration n_neighbors_ecal_eq_0: int Number of neighbors to use by default for k_neighbors queries. for ecal == 0 n_neighbors_ecal_neq_0: int Number of neighbors to use by default for k_neighbors queries. for ecal != 0 weight : str or callable weight function used in prediction. Possible values: 'uniform' : uniform weights. All points in each neighborhood are weighted equally. 'distance' : weight points by the inverse of their distance. in this case, closer neighbors of a query point will have a greater influence than neighbors which are further away. [callable] : a user-defined function which accepts an array of distances, and returns an array of the same shape containing the weights. 'gaussian' Gaussian weights are used by default. algortihm : {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, optional Algorithm used to compute the nearest neighbors: 'ball_tree' will use BallTree 'kd_tree' will use KDtree 'brute' will use a brute-force search. 'auto' will attempt to decide the most appropriate algorithm based on the values passed to fit method. sigma : float sigma for the gaussian if weight == 'gaussian' lim : float to reject calibration points with ecal + hcal > lim if lim = - 1, there is no limit energystep : float step between two points of evaluation kind : str or int, optional Specifies the kind of interpolation as a string (‘linear’, ‘nearest’, ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’ where ‘zero’, ‘slinear’, ‘quadratic’ and ‘cubic’ refer to a spline interpolation of zeroth, first, second or third order) or as an integer specifying the order of the spline interpolator to use. Default is ‘linear’ cut : float cut to reject points we only consider the points with true energy between mu - cut * sigma and mu - cut * sigma (mu and sigma the mean and std of the gaussian fit) """ Calibration.__init__(self, ecal_train, hcal_train, true_train, lim) self.n_neighbors_ecal_eq_0 = n_neighbors_ecal_eq_0 self.n_neighbors_ecal_neq_0 = n_neighbors_ecal_neq_0 self.algorithm = algorithm self.sigma = sigma self.kind = kind self.cut = cut self.evaluatedPoint_hcal_ecal_eq_0 = [] self.evaluatedPoint_true_ecal_eq_0 = [] self.evaluatedPoint_neighbours_hcal_ecal_eq_0 = [] self.evaluatedPoint_neighbours_true_ecal_eq_0 = [] self.evaluatedPoint_parameters_ecal_eq_0 = [] self.evaluatedPoint_entries_ecal_eq_0 = [] self.evaluatedPoint_bin_middles_ecal_eq_0 = [] self.evaluatedPoint_true_min_ecal_eq_0 = [] self.evaluatedPoint_true_max_ecal_eq_0 = [] self.evaluatedPoint_ecal = [] self.evaluatedPoint_hcal = [] self.evaluatedPoint_true = [] self.evaluatedPoint_neighbours_ecal = [] self.evaluatedPoint_neighbours_hcal = [] self.evaluatedPoint_neighbours_true = [] self.evaluatedPoint_parameters = [] self.evaluatedPoint_entries = [] self.evaluatedPoint_bin_middles = [] self.evaluatedPoint_true_min = [] self.evaluatedPoint_true_max = [] # we define the weight if weights == 'gaussian': self.weights = lambda x: np.exp(-(x**2) / (sigma**2) / 2) else: self.weights = weights #Case ecal == 0 self.neigh_ecal_eq_0 = neighbors.NearestNeighbors( n_neighbors=n_neighbors_ecal_eq_0, algorithm=algorithm) y = self.hcal_train[self.ecal_train == 0] z = self.true_train[self.ecal_train == 0] self.neigh_ecal_eq_0.fit(np.transpose(np.matrix(y))) def forOnePoint_ecal_eq_0(h): # the neighbours of the point (ecal,hcal) = (0,h) dist, ind = self.neigh_ecal_eq_0.kneighbors(X=h) true = z[ind][0] hcal = y[ind][0] nbins = int(max(true)) with warnings.catch_warnings(): try: #we create the histogram warnings.simplefilter("error", OptimizeWarning) entries, bin_edges = np.histogram(true, bins=nbins) bin_middles = 0.5 * (bin_edges[1:] + bin_edges[:-1]) # we fit the histogram p0 = np.sqrt(np.std(entries)), bin_middles[np.argmax( entries)], max(entries) parameters, cov_matrix = curve_fit(gaussian_param, bin_middles, entries, p0=p0) true_max = parameters[1] + self.cut * parameters[0] true_min = parameters[1] - self.cut * parameters[0] # we select the good neighbours selected = np.logical_and(true >= true_min, true <= true_max) hcal = hcal[selected] true = true[selected] # pondered mean of the neighbourhood true = np.transpose(np.matrix(true)) hcal = np.transpose(np.matrix(hcal)) regr = neighbors.KNeighborsRegressor( n_neighbors=len(true), weights=self.weights, algorithm=self.algorithm) regr.fit(hcal, true) res = regr.predict(h) except: parameters = p0 true = np.transpose(np.matrix(z[ind][0])) hcal = np.transpose(np.matrix(y[ind][0])) regr = neighbors.KNeighborsRegressor( n_neighbors=len(true), weights=self.weights, algorithm=self.algorithm) regr.fit(hcal, true) res = regr.predict(h) true_min = min(z[ind][0]) true_max = max(z[ind][0]) finally: # we save the values in the attributs self.evaluatedPoint_parameters_ecal_eq_0.append(parameters) self.evaluatedPoint_neighbours_hcal_ecal_eq_0.append(hcal) self.evaluatedPoint_neighbours_true_ecal_eq_0.append(true) self.evaluatedPoint_entries_ecal_eq_0.append(entries) self.evaluatedPoint_bin_middles_ecal_eq_0.append( bin_middles) self.evaluatedPoint_true_min_ecal_eq_0.append(true_min) self.evaluatedPoint_true_max_ecal_eq_0.append(true_max) self.evaluatedPoint_hcal_ecal_eq_0.append(h) self.evaluatedPoint_true_ecal_eq_0.append(res) return res #we define the first point of evaluation dist, ind = self.neigh_ecal_eq_0.kneighbors(X=0) hcal = y[ind][0] hcal_min = (max(hcal) + min(hcal)) / 2 # we evaluate the true energies hcal = np.linspace(hcal_min, self.lim, (self.lim - hcal_min) / energystep) vect = np.vectorize(forOnePoint_ecal_eq_0) true = vect(hcal) # we create the interpolation self.interpolation_ecal_eq_0 = interp1d(hcal, true, kind=kind, fill_value='extrapolate') # Case ecal != 0 self.neigh_ecal_neq_0 = neighbors.NearestNeighbors( n_neighbors=n_neighbors_ecal_neq_0, algorithm=algorithm) x = self.ecal_train[self.ecal_train != 0] y = self.hcal_train[self.ecal_train != 0] z = self.true_train[self.ecal_train != 0] self.neigh_ecal_neq_0.fit(np.transpose(np.matrix([x, y]))) def forOnePoint_ecal_neq_0(e, h): # the neighbours of the point (ecal,hcal) = (e,h) dist, ind = self.neigh_ecal_neq_0.kneighbors([[e, h]]) true = z[ind][0] hcal = y[ind][0] ecal = x[ind][0] nbins = int(max(true)) with warnings.catch_warnings(): try: #we create the histogram warnings.simplefilter("error", OptimizeWarning) entries, bin_edges = np.histogram(true, bins=nbins) bin_middles = 0.5 * (bin_edges[1:] + bin_edges[:-1]) # we fit the histogram p0 = np.sqrt(np.std(entries)), bin_middles[np.argmax( entries)], max(entries) parameters, cov_matrix = curve_fit(gaussian_param, bin_middles, entries, p0=p0) # we define the max and the min te reject points true_max = parameters[1] + self.cut * parameters[0] true_min = parameters[1] - self.cut * parameters[0] # we select the good neighbours selected = np.logical_and(true >= true_min, true <= true_max) hcal = hcal[selected] true = true[selected] ecal = ecal[selected] # gaussian mean of the neighbourhood true = np.transpose(np.matrix(true)) Ecal = np.transpose(np.matrix([ecal, hcal])) regr = neighbors.KNeighborsRegressor( n_neighbors=len(true), weights=self.weights, algorithm=self.algorithm) regr.fit(Ecal, true) res = regr.predict([[e, h]]) res = res[0][0] except: parameters = p0 true_min = min(z[ind][0]) true_max = max(z[ind][0]) true = np.transpose(np.matrix(z[ind][0])) Ecal = np.transpose(np.matrix([x[ind][0], y[ind][0]])) regr = neighbors.KNeighborsRegressor( n_neighbors=len(true), weights=self.weights, algorithm=self.algorithm) regr.fit(Ecal, true) res = regr.predict([[e, h]]) res = res[0][0] finally: # we save the values in the attributs self.evaluatedPoint_neighbours_ecal.append(ecal) self.evaluatedPoint_neighbours_hcal.append(hcal) self.evaluatedPoint_neighbours_true.append(true) self.evaluatedPoint_entries.append(entries) self.evaluatedPoint_bin_middles.append(bin_middles) self.evaluatedPoint_ecal.append(e) self.evaluatedPoint_hcal.append(h) self.evaluatedPoint_true.append(res) self.evaluatedPoint_parameters.append(parameters) self.evaluatedPoint_true_min.append(true_min) self.evaluatedPoint_true_max.append(true_max) return res #we define the first point of evaluation dist, ind = self.neigh_ecal_neq_0.kneighbors(X=[[0, 0]]) hcal = y[ind][0] ecal = x[ind][0] hcal_min = (max(hcal) + min(hcal)) / 2 ecal_min = (max(ecal) + min(ecal)) / 2 # we evaluate the true energies hcal = np.linspace(hcal_min, self.lim, (self.lim - hcal_min) / energystep) ecal = np.linspace(ecal_min, self.lim, (self.lim - ecal_min) / energystep) eecal, hhcal = np.meshgrid(ecal, hcal) vect = np.vectorize(forOnePoint_ecal_neq_0) true = vect(eecal, hhcal) # we create the interpolation self.interpolation_ecal_neq_0 = interp2d(ecal, hcal, true, kind=kind)
def __init__(self, ecal_train=[], hcal_train=[], true_train=[], n_neighbors_ecal_eq_0=2000, n_neighbors_ecal_neq_0=250, algorithm='auto', lim=-1, energystep_ecal_eq_0=1, energystep_ecal_neq_0=5, kind='cubic'): """ Parameters ---------- ecal_train : array-like ecal value to train the calibration hcal_train : array-like hcal value to train the calibration true_train : array-like true value to train the calibration n_neighbors_ecal_eq_0: int Number of neighbors to use by default for k_neighbors queries. for ecal == 0 n_neighbors_ecal_neq_0: int Number of neighbors to use by default for k_neighbors queries. for ecal != 0 algortihm : {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, optional Algorithm used to compute the nearest neighbors: 'ball_tree' will use BallTree 'kd_tree' will use KDtree 'brute' will use a brute-force search. 'auto' will attempt to decide the most appropriate algorithm based on the values passed to fit method. lim : float to reject calibration points with ecal + hcal > lim if lim = - 1, there is no limit energystep_ecal_eq_0 : float step between two points of evaluation for ecal == 0 energystep_ecal_neq_0 : float step between two points of evaluation for ecal != 0 kind : str or int, optional Specifies the kind of interpolation as a string (‘linear’, ‘nearest’, ‘zero’, ‘slinear’, ‘quadratic’, ‘cubic’ where ‘zero’, ‘slinear’, ‘quadratic’ and ‘cubic’ refer to a spline interpolation of zeroth, first, second or third order) or as an integer specifying the order of the spline interpolator to use. Default is ‘linear’ """ Calibration.__init__(self, ecal_train, hcal_train, true_train, lim) self.n_neighbors_ecal_eq_0 = n_neighbors_ecal_eq_0 self.n_neighbors_ecal_neq_0 = n_neighbors_ecal_neq_0 self.algorithm = algorithm self.kind = kind self.evaluatedPoint_hcal_ecal_eq_0 = [] self.evaluatedPoint_true_ecal_eq_0 = [] self.evaluatedPoint_neighbours_hcal_ecal_eq_0 = [] self.evaluatedPoint_neighbours_true_ecal_eq_0 = [] self.evaluatedPoint_parameters_ecal_eq_0 = [] self.evaluatedPoint_entries_ecal_eq_0 = [] self.evaluatedPoint_bin_middles_ecal_eq_0 = [] self.evaluatedPoint_ecal = [] self.evaluatedPoint_hcal = [] self.evaluatedPoint_true = [] self.evaluatedPoint_neighbours_ecal = [] self.evaluatedPoint_neighbours_hcal = [] self.evaluatedPoint_neighbours_true = [] self.evaluatedPoint_parameters = [] self.evaluatedPoint_entries = [] self.evaluatedPoint_bin_middles = [] self.evaluatedPoint_reducedchi2 = [] self.evaluatedPoint_reducedchi2_ecal_eq_0 = [] #Case ecal == 0 self.neigh_ecal_eq_0 = neighbors.NearestNeighbors( n_neighbors=self.n_neighbors_ecal_eq_0, algorithm=algorithm) y = self.hcal_train[self.ecal_train == 0] self.hcal_train_ecal_eq_0_min = min(y) z = self.true_train[self.ecal_train == 0] self.neigh_ecal_eq_0.fit(np.transpose(np.matrix(y))) def forOnePoint_ecal_eq_0(h): # the neighbours of the point (ecal,hcal) = (0,h) dist, ind = self.neigh_ecal_eq_0.kneighbors(X=h) dist = dist[0] ind = ind[0] dlim = h - self.hcal_train_ecal_eq_0_min + 0.1 ind = ind[dist <= dlim] true = z[ind] hcal = y[ind] binwidth = 1 reduced = math.nan with warnings.catch_warnings(): try: if len(true) == 0: raise UserWarning nbins = np.arange(min(true), max(true) + binwidth, binwidth) #we create the histogram warnings.simplefilter("error", OptimizeWarning) entries, bin_edges = np.histogram(true, bins=nbins) bin_middles = 0.5 * (bin_edges[1:] + bin_edges[:-1]) bin_middles = bin_middles[entries != 0] entries = entries[entries != 0] # we fit the histogram p0 = np.sqrt(np.std(entries)), bin_middles[np.argmax( entries)], max(entries) error = np.sqrt(entries) parameters, cov_matrix = curve_fit(gaussian_param, bin_middles, entries, sigma=error, p0=p0) res = parameters[1] chi2 = np.sum( ((gaussian_param(bin_middles, *parameters) - entries) / error)**2) reduced = chi2 / (len(bin_middles) - len(parameters)) if reduced > 10: raise OptimizeWarning except UserWarning: parameters = math.nan entries = math.nan res = math.nan bin_middles = math.nan print("calibration issue for ecal = 0, hcal = ", h, "reduced chi2 = ", reduced) except (OptimizeWarning, RuntimeError): parameters = p0 res = parameters[1] print("calibration issue for ecal = 0, hcal = ", h, "reduced chi2 = ", reduced) finally: # we save the values in the attributs self.evaluatedPoint_hcal_ecal_eq_0.append(h) self.evaluatedPoint_true_ecal_eq_0.append(res) self.evaluatedPoint_parameters_ecal_eq_0.append(parameters) self.evaluatedPoint_neighbours_hcal_ecal_eq_0.append(hcal) self.evaluatedPoint_neighbours_true_ecal_eq_0.append(true) self.evaluatedPoint_entries_ecal_eq_0.append(entries) self.evaluatedPoint_bin_middles_ecal_eq_0.append( bin_middles) self.evaluatedPoint_reducedchi2_ecal_eq_0.append(reduced) return res #we define the first point of evaluation dist, ind = self.neigh_ecal_eq_0.kneighbors(X=0) hcal = y[ind][0] hcal_min = (max(hcal) + min(hcal)) / 2 # we evaluate the true energies hcal = np.arange(hcal_min, self.lim + energystep_ecal_eq_0, energystep_ecal_eq_0) vect = np.vectorize(forOnePoint_ecal_eq_0) true = vect(hcal) hcal = hcal[np.invert(np.isnan(true))] true = true[np.invert(np.isnan(true))] # we create the interpolation self.interpolation_ecal_eq_0 = interp1d(hcal, true, kind=kind, fill_value='extrapolate') # Case ecal != 0 self.neigh_ecal_neq_0 = neighbors.NearestNeighbors( n_neighbors=self.n_neighbors_ecal_neq_0, algorithm=algorithm) x = self.ecal_train[self.ecal_train != 0] y = self.hcal_train[self.ecal_train != 0] z = self.true_train[self.ecal_train != 0] self.neigh_ecal_neq_0.fit(np.transpose(np.matrix([x, y]))) def forOnePoint_ecal_neq_0(e, h): # the neighbours of the point (ecal,hcal) = (e,h) dist, ind = self.neigh_ecal_neq_0.kneighbors([[e, h]]) true = z[ind][0] hcal = y[ind][0] ecal = x[ind][0] binwidth = 1 nbins = np.arange(min(true), max(true) + binwidth, binwidth) with warnings.catch_warnings(): try: #we create the histogram warnings.simplefilter("error", OptimizeWarning) entries, bin_edges = np.histogram(true, bins=nbins) bin_middles = 0.5 * (bin_edges[1:] + bin_edges[:-1]) bin_middles = bin_middles[entries != 0] entries = entries[entries != 0] reduced = math.nan # we fit the histogram p0 = np.sqrt(np.std(entries)), bin_middles[np.argmax( entries)], max(entries) error = np.sqrt(entries) parameters, cov_matrix = curve_fit(gaussian_param, bin_middles, entries, sigma=error, p0=p0) res = parameters[1] chi2 = np.sum( ((gaussian_param(bin_middles, *parameters) - entries) / error)**2) reduced = chi2 / (len(bin_middles) - len(parameters)) if reduced > 10: raise OptimizeWarning except (OptimizeWarning, RuntimeError): parameters = p0 res = parameters[1] if e + h < self.lim: print("calibration issue for ecal = ", e, " hcal = ", h) finally: # we save the values in the attributs self.evaluatedPoint_neighbours_ecal.append(ecal) self.evaluatedPoint_neighbours_hcal.append(hcal) self.evaluatedPoint_neighbours_true.append(true) self.evaluatedPoint_entries.append(entries) self.evaluatedPoint_bin_middles.append(bin_middles) self.evaluatedPoint_ecal.append(e) self.evaluatedPoint_hcal.append(h) self.evaluatedPoint_true.append(res) self.evaluatedPoint_parameters.append(parameters) self.evaluatedPoint_reducedchi2.append(reduced) return res #we define the first point of evaluation dist, ind = self.neigh_ecal_neq_0.kneighbors(X=[[0, 0]]) hcal = y[ind][0] ecal = x[ind][0] hcal_min = (max(hcal) + min(hcal)) / 2 ecal_min = (max(ecal) + min(ecal)) / 2 # we evaluate the true energies hcal = np.linspace(hcal_min, self.lim, (self.lim - hcal_min) / energystep_ecal_neq_0) ecal = np.linspace(ecal_min, self.lim, (self.lim - ecal_min) / energystep_ecal_neq_0) eecal, hhcal = np.meshgrid(ecal, hcal) vect = np.vectorize(forOnePoint_ecal_neq_0) true = vect(eecal, hhcal) # we create the interpolation self.interpolation_ecal_neq_0 = interp2d(ecal, hcal, true, kind=kind)
def __init__(self, ecal_train=[], hcal_train=[], true_train=[], n_neighbors_ecal_eq_0=2000, n_neighbors_ecal_neq_0=250, weights='gaussian', algorithm='auto', sigma=5, lim=-1): """ Parameters ---------- ecal_train : array-like ecal value to train the calibration hcal_train : array-like hcal value to train the calibration true_train : array-like true value to train the calibration n_neighbors_ecal_eq_0: int Number of neighbors to use by default for k_neighbors queries. for ecal == 0 n_neighbors_ecal_neq_0: int Number of neighbors to use by default for k_neighbors queries. for ecal != 0 weight : str or callable weight function used in prediction. Possible values: 'uniform' : uniform weights. All points in each neighborhood are weighted equally. 'distance' : weight points by the inverse of their distance. in this case, closer neighbors of a query point will have a greater influence than neighbors which are further away. [callable] : a user-defined function which accepts an array of distances, and returns an array of the same shape containing the weights. 'gaussian' Gaussian weights are used by default. algortihm : {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, optional Algorithm used to compute the nearest neighbors: 'ball_tree' will use BallTree 'kd_tree' will use KDtree 'brute' will use a brute-force search. 'auto' will attempt to decide the most appropriate algorithm based on the values passed to fit method. sigma : float sigma for the gaussian if weight == 'gaussian' lim : float if ecal + hcal > lim, the calibrated energy ecalib = math.nan if lim = - 1, there is no limit """ # We use the constructor of the mother class Calibration.__init__(self, ecal_train, hcal_train, true_train, lim) # we define the weight if weights == 'gaussian': self.weights = lambda x: np.exp(-(x**2) / (sigma**2) / 2) else: self.weights = weights self.n_neighbors_ecal_eq_0 = n_neighbors_ecal_eq_0 self.n_neighbors_ecal_neq_0 = n_neighbors_ecal_neq_0 self.algorithm = algorithm self.sigma = sigma # Case ecal != 0 X_train = [ecal_train[ecal_train != 0], hcal_train[ecal_train != 0]] self.X_train1 = X_train X_train = np.transpose(np.matrix(X_train)) Y_train = true_train[ecal_train != 0] self.Y_train1 = Y_train Y_train = np.transpose(np.matrix(Y_train)) self.neigh_ecal_neq_0 = neighbors.KNeighborsRegressor( n_neighbors=n_neighbors_ecal_neq_0, weights=self.weights, algorithm=self.algorithm) self.neigh_ecal_neq_0.fit(X_train, Y_train) #case ecal == 0 X_train = hcal_train[ecal_train == 0] self.X_train2 = X_train X_train = np.transpose(np.matrix(X_train)) Y_train = true_train[ecal_train == 0] self.Y_train2 = Y_train Y_train = np.transpose(np.matrix(Y_train)) self.neigh_ecal_eq_0 = neighbors.KNeighborsRegressor( n_neighbors=n_neighbors_ecal_eq_0, weights=self.weights, algorithm=algorithm) self.neigh_ecal_eq_0.fit(X_train, Y_train)
def __init__(self,ecal_train=[],hcal_train=[],true_train=[],lim_min=-1,lim_max=-1,lim=-1): """ Constructor of the class Parameters --------- ecal_train : array ecal value to train the calibration hcal_train : array ecal value to train the calibration true_train : array ecal value to train the calibration lim_min : float linear regression is done with points with ecal + hcal > lim_min if lim_min = - 1, there is no limit lim_max : float linear regression is done with points with ecal + hcal < lim_max if lim_max = - 1, there is no limit lim : float if ecal + hcal > lim, the calibrated energy ecalib = math.nan if lim = - 1, there is no limit """ # We use the constructor of the mother class Calibration.__init__(self,ecal_train,hcal_train,true_train,lim) self.lim_min = lim_min self.lim_max = lim_max if lim_min == -1: ind_min = np.ones(len(self.ecal_train),dtype=bool) else: ind_min = self.ecal_train + self.hcal_train > lim_min if lim_max == -1: ind_max = np.ones(len(self.ecal_train),dtype=bool) else: ind_max = self.ecal_train+ self.hcal_train < lim_max #CASE : ecal != 0 ind_0 = self.ecal_train != 0 ind = np.logical_and(ind_min,ind_max) ind = np.logical_and(ind,ind_0) X_train = [self.ecal_train[ind],self.hcal_train[ind]] X_train = np.transpose(np.matrix(X_train)) Y_train = self.true_train[ind] Y_train = np.transpose(np.matrix(Y_train)) linRegr_ecal_neq_0 = linear_model.LinearRegression() linRegr_ecal_neq_0.fit(X_train,Y_train) #CASE : ecal == 0 ind_0 = self.ecal_train == 0 ind = np.logical_and(ind_min,ind_max) ind = np.logical_and(ind,ind_0) X_train = self.hcal_train[ind] X_train = np.transpose(np.matrix(X_train)) Y_train = self.true_train[ind] Y_train = np.transpose(np.matrix(Y_train)) linRegr_ecal_eq_0 = linear_model.LinearRegression() linRegr_ecal_eq_0.fit(X_train,Y_train) self.linRegr_ecal_neq_0 = linRegr_ecal_neq_0 self.linRegr_ecal_eq_0 = linRegr_ecal_eq_0
def __init__(self, ecal_train=[], hcal_train=[], true_train=[], nbLego=60, lim=150): """ Parameters ---------- ecal_train : array ecal value to train the calibration hcal_train : array ecal value to train the calibration true_train : array ecal value to train the calibration lim : float if ecal + hcal > lim, the calibrated energy ecalib = math.nan if lim = - 1, there is no limit nbLego : int The plane (ecal,hcal) is divided in nbLego*nbLego """ Calibration.__init__(self, ecal_train, hcal_train, true_train, lim) nbLego = int(nbLego) self.nbLego = nbLego ener_max = max(max(self.hcal_train), max(self.ecal_train)) ecal = np.linspace(0, ener_max, nbLego) hcal = np.linspace(0, ener_max, nbLego) self.delta = hcal[1] - hcal[0] self.nbLego = nbLego ecal_calib = [] hcal_calib = [] true_calib = [] # when ecal == 0 true_calib_lim = [] precision = [] bins_ecal = np.arange(nbLego - 1) bins_hcal = np.arange(nbLego - 1) for i in bins_ecal: ind_ecal = np.logical_and(self.ecal_train >= ecal[i], self.ecal_train < ecal[i + 1]) ind_ecal = np.logical_and(self.ecal_train != 0, ind_ecal) for j in bins_hcal: ind_hcal = np.logical_and(self.hcal_train >= hcal[j], self.hcal_train < hcal[j + 1]) ind_true = np.logical_and(ind_ecal, ind_hcal) true = self.true_train[ind_true] if true.size != 0: true_calib.append(np.mean(true)) precision.append( np.std(true) / np.sqrt(len(true)) / np.mean(true)) else: true_calib.append(math.nan) precision.append(None) ecal_calib.append(np.mean([ecal[i], ecal[i + 1]])) hcal_calib.append(np.mean([hcal[j], hcal[j + 1]])) # when ecal == 0 for i in bins_hcal: ind_hcal = np.logical_and(self.hcal_train >= hcal[i], self.hcal_train < hcal[i + 1]) ind_true = np.logical_and(self.ecal_train == 0, ind_hcal) true = self.true_train[ind_true] if true.size != 0: true_calib_lim.append(np.mean(true)) else: true_calib_lim.append(math.nan) self.ecal = np.array(ecal_calib) self.ecal_max = max(self.ecal) self.hcal = np.array(hcal_calib) self.hcal_max = max(self.hcal) self.true = np.array(true_calib) self.true_lim = np.array(true_calib_lim) self.precision = np.array(precision)