def scale_spectra(spec1, spec2, wlmin=None, wlmax=None, scale_factor=False): ''' Scale spec1 to spec2 by integrating from wlmin to wlmax and using the area as a scaling factor Inputs: spec1, spec2: two spectrum1d objects with attributes wave and flux wlmin: shortest wavelength to be used in scaling wlmax: longest wavelength to be used in scaling Outputs: spec1: spec1d object with scaled flux scale_factor (optional): if scale_factor = True, then the multiplicative factor is returned ''' if wlmin is None: wlmin = max(spec1.wave.min(), spec2.wave.min()) if wlmax is None: wlmax = min(spec1.wave.max(), spec2.wave.max()) windx_1 = (spec1.wave >= wlmin) & (spec1.wave <= wlmax) windx_2 = (spec2.wave >= wlmin) & (spec2.wave <= wlmax) area1 = integrate.trapezoid(spec1.flux[windx_1], x=spec1.wave[windx_1]) area2 = integrate.trapezoid(spec2.flux[windx_2], x=spec2.wave[windx_2]) spec1 = spectrum1d(spec1.wave, spec1.flux / area1 * area2) if scale_factor is True: return spec1, area2 / area1 else: return spec1
def calc_tw(tw_in, beta_phiw, beta_psi_charge, charge_pair, rho, f1, f2, z, n_component, n_point, z_index): tw = np.zeros((n_point, n_component)) integral_z_infty = np.zeros((n_point, n_component)) integral_0_z = np.zeros((n_point, n_component)) TWO_PI = 2.0 * np.pi hw = calc_hw(tw_in, n_component, beta_phiw) for i in range(n_component): for k in range(n_point): integral_0_z[k, i] = trapezoid(y=hw[:k, i], x=z[:k]) integral_z_infty[k, i] = trapezoid(y=z[k:] * hw[k:, i], x=z[k:]) for i in range(n_component): for k in range(n_point): z_minus_t = np.flip(z_index[:k]) t_minus_z = z_index[k:] - k for j in range(i, n_component): l = calc_l_index(i, j) tw[k, i] = beta_psi_charge[i] tw[k, i] += TWO_PI * rho[j] * ( z[k] * f1[k, l] - f2[k, l] + charge_pair[l] * (integral_z_infty[k, j] + z[k] * integral_0_z[k, j]) + trapezoid(y=hw[:k, j] * f1[z_minus_t, l]) + trapezoid(y=hw[k:, j] * f1[t_minus_z, l])) return tw
def test_trapezoid(self): y = np.arange(17) assert_equal(trapezoid(y), 128) assert_equal(trapezoid(y, dx=0.5), 64) assert_equal(trapezoid(y, x=np.linspace(0, 4, 17)), 32) y = np.arange(4) x = 2**y assert_equal(trapezoid(y, x=x, dx=0.1), 13.5)
def evaluate(self, heatmap, img): # noqa """# TODO to add docs Args: heatmap (Tensor): heatmap with shape (H, W) or (3, H, W). img (Tensor): image with shape (3, H, W). Returns: dict[str, Union[Tensor, np.array, float]]: a dictionary containing following fields - del_scores: ndarray, - ins_scores: - del_img: - ins_img: - ins_auc: - del_auc: """ # compress heatmap to 2D if needed if heatmap.ndim == 3: heatmap = heatmap.mean(0) heatmap = heatmap.mean(0) # sort pixel in attribution num_pixels = torch.numel(heatmap) _, indices = torch.topk(heatmap.flatten(), num_pixels) indices = np.unravel_index(indices.cpu().numpy(), heatmap.size()) # apply deletion game deletion_perturber = PixelPerturber(img, torch.zeros_like(img)) deletion_scores = self._procedure_perturb(deletion_perturber, num_pixels, indices) # apply insertion game blurred_img = self.gaussian_blurr(img) insertion_perturber = PixelPerturber(blurred_img, img) insertion_scores = self._procedure_perturb(insertion_perturber, num_pixels, indices) # calculate AUC insertion_auc = trapezoid(insertion_scores, dx=1. / len(insertion_scores)) deletion_auc = trapezoid(deletion_scores, dx=1. / len(deletion_scores)) # deletion_img and insertion_img are final results, they are only used for debug purpose # TODO check if it is necessary to convert the Tensors to np.ndarray return { "del_scores": deletion_scores, "ins_scores": insertion_scores, "del_img": deletion_perturber.get_current(), "ins_img": insertion_perturber.get_current(), "ins_auc": insertion_auc, "del_auc": deletion_auc }
def price(self, strike, spot, texp, cp=1): ''' Your MC routine goes here Generate paths for vol only. Then compute integrated variance and normal price. You may fix the random number seed ''' np.random.seed(12345) option_num = strike.shape[0] self.option_prices = np.zeros(option_num) dt = 0.01 time_num = round(texp / dt) path_num = 10000 stockpath = np.zeros((time_num + 1, path_num)) stockpath[0, :] = spot sigmapath = np.zeros((time_num + 1, path_num)) sigmapath[0, :] = self.sigma for i in range(time_num): t_row = i + 1 z = np.random.randn(path_num) sigmapath[t_row, :] = sigmapath[i, :] * np.exp( self.vov * np.sqrt(dt) * z - 0.5 * self.vov**2 * dt) self.sigmapath = sigmapath self.I_T = spint.trapezoid(sigmapath**2, dx=dt, axis=0) self.stock_prices = spot + self.rho / self.vov * (sigmapath[-1, :] - self.sigma) self.sigma_n = np.sqrt((1 - self.rho**2) * self.I_T / texp) self.option_prices = np.mean(self.normal_formula( strike, self.stock_prices, texp, self.sigma_n), axis=1) return self.option_prices
def get_auprc(self, scores): res = prc_curve(scores, self.anomaly.y[self.data.I[0]]) _res = pd.DataFrame( res, columns=('ppv', 'tpr'), ).groupby('tpr').max().reset_index()[['ppv', 'tpr']].values return trapezoid(*_res.T)
def integral_z_infty_dr_r2_c_short(c_short, n_pair, n_point, z): integrand = np.zeros(n_point) f2 = np.zeros((n_point, n_pair)) for ij in range(n_pair): integrand[:] = z * z * c_short[:, ij] for k, _ in enumerate(z): f2[k:, ij] = trapezoid(y=integrand[k:], x=z[k:]) return f2
def __compute_energy(self): energy = [] for state in [0, 1]: #0 is discharge, 1 is charge current = self.filter_row("ox/red", state)["(Q-Qo)/mA.h"] voltage = self.filter_row("ox/red", state)["Ewe/V"] energy.append(integrate.trapezoid(voltage, x=current)) self.energy_charge = energy[1] self.energy_discharge = -energy[0]
def sirens_dist(label): # redshift limits z_min = 0 z_max = 10 # Pop III if label == "Pop III": min = 0 max = 8.0 z = [0, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10] n = [0, 2, 7, 8, 5.25, 3.25, 1.5, 0.5, 0.25, 0, 0, 0] N = trapezoid(n, z) f = interp1d(z, n) # Delay elif label == "Delay": min = 0 max = 6.0 z = [0, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10] n = [0, 1, 4.1, 6, 5.2, 4.8, 2.7, 1.8, 0.7, 0.4, 0.1, 0] N = trapezoid(n, z) f = interp1d(z, n) # No Delay elif label == "No Delay": min = 0 max = 10.3 z = [0, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5, 8.5, 9.5, 10] n = [0, 3.7, 10.3, 9.4, 7.7, 5, 2.9, 1.2, 0.5, 0.2, 0, 0] N = trapezoid(n, z) f = interp1d(z, n) # no such label exists else: raise Exception("Label not available, available labels are: Pop III, Delay, No Delay") return (f, z_min, z_max, min, max, N)
def frac_area_latency(inst, mode='abs', frac=None, tmin=None, tmax=None): # Get Data vector and sample indicies for tmin and tmax ch_names = inst.info['ch_names'] data = np.squeeze(inst.data) * 1e6 times = inst.times speriod = 1 / inst.info['sfreq'] time_win, smin, smax = _get_time_win(times, tmin=tmin, tmax=tmax, return_sample=True) # Process data based on mode if mode == 'pos': data[data < 0] = 0 elif mode == 'neg': data[data > 0] = 0 data = np.abs(data) # Always rectify # Compute area between tmin and tmax (in time_win) area = trapezoid(data[:, time_win], dx=speriod, axis=1) if frac is None or frac == 1.0: return ch_names, area # Compute cumulative area by finding nearest 'cumulative' area frac_area = area * frac running_area = np.ones_like(data) * 10 for i, sx in enumerate(np.arange(smin + 1, smax + 1)): a = trapezoid(data[:, smin:sx], dx=speriod, axis=1) running_area[:, smin + i] = a search_samples = np.arange(smin, smax + 1) frac_lat_samples = _find_nearest(running_area[:, time_win], frac_area[:, None], axis=1, return_index=True) frac_true_samples = search_samples[frac_lat_samples] frac_lat_times = times[frac_true_samples] # Return computed values return ch_names, area, frac_lat_times
def trapeziod_integral_df(waveforms, dx=1): ''' waveforms: the waveforms collection DataFrame dx: the interval between the y-values ''' Integrals = [] for i in range(waveforms.shape[1]): event = waveforms[waveforms.columns[i]] integral = trapezoid(y=event, dx=dx) Integrals.append(integral) return (pd.DataFrame(Integrals, index=waveforms.columns))
def plot_roc_precrec(df): """ Plot ROC and PrecRec, also calc and return AUC Pass perf df from calc.calc_binary_performance_measures """ roc_auc = integrate.trapezoid(y=df['tpr'], x=df['fpr']) prec_rec_auc = integrate.trapezoid(y=df['precision'], x=df['recall']) f, axs = plt.subplots(1, 2, figsize=(11.5, 6), sharex=True, sharey=True) _ = f.suptitle('ROC and Precision Recall Curves', y=1.0) _ = axs[0].plot(df['fpr'], df['tpr'], lw=2, marker='d', alpha=0.8, label=f"ROC (auc={roc_auc:.2f})") _ = axs[0].plot((0, 1), (0, 1), '--', c='#cccccc', label='line of equiv') _ = axs[0].legend(loc='upper left') _ = axs[0].set(title='ROC curve', xlabel='FPR', ylabel='TPR') _ = axs[1].plot(df['recall'], df['precision'], lw=2, marker='o', alpha=0.8, color='C3', label=f"PrecRec (auc={prec_rec_auc:.2f})") _ = axs[1].legend(loc='upper right') _ = axs[1].set(title='Precision Recall curve', xlabel='Recall', ylabel='Precision') f.tight_layout() return roc_auc, prec_rec_auc
def plot_coverage(df, title_add=''): """ Convenience plot coverage from mt.calc_ppc_coverage """ txt_kws = dict(color='#333333', xycoords='data', xytext=(2, -4), textcoords='offset points', fontsize=11, backgroundcolor='w') g = sns.lmplot(x='cr', y='coverage', col='method', hue='method', data=df, fit_reg=False, height=5, scatter_kws={'s': 70}) for i, method in enumerate(df['method'].unique()): idx = df['method'] == method y = df.loc[idx, 'coverage'].values x = df.loc[idx, 'cr'].values ae = np.abs(y - x) auc = integrate.trapezoid(ae, x) g.axes[0][i].plot((0, 1), (0, 1), ls='--', color='#aaaaaa', zorder=-1) g.axes[0][i].fill_between(x, y, x, color='#bbbbbb', alpha=0.8, zorder=-1) g.axes[0][i].annotate(f'AUC={auc:.3f}', xy=(0, 1), **txt_kws) if title_add != '': title_add = f': {title_add}' g.fig.suptitle((f'PPC Coverage vs CR{title_add}'), y=1.05) return None
def integrate_variable_data(data): """ """ # TODO: Only integrate certain sets # TODO: actually test this function... sets = data["sets"] indices = data["indices"] variables = data["variables"] if sets is None: return {name: 0.0 for name in variables} else: indices = list(indices) variables = dict(variables) for name, values in variables.items(): array = np.array(values) for i in range(len(indices)): axis = len(indices) - i - 1 x = indices[axis] array = integrate.trapezoid(array, x=x, axis=axis) variables[name] = array.tolist() return variables
def get_area(scan, area_method, lorentz): if area_method not in AREA_METHODS: raise ValueError(f"Unknown area method: {area_method}.") if area_method == "fit_area": area_v = 0 area_s = 0 for name, param in scan["fit"].params.items(): if "amplitude" in name: if param.stderr is None: area_v = np.nan area_s = np.nan else: area_v += param.value area_s += param.stderr else: # area_method == "int_area" y_val = scan["counts"] x_val = scan[scan["scan_motor"]] y_bkg = scan["fit"].eval_components(x=x_val)["f0_"] area_v = simpson(y_val, x=x_val) - trapezoid(y_bkg, x=x_val) area_s = np.sqrt(area_v) if lorentz: # lorentz correction to area if scan["zebra_mode"] == "bi": twotheta = np.deg2rad(scan["twotheta"]) corr_factor = np.sin(twotheta) else: # zebra_mode == "nb": gamma = np.deg2rad(scan["gamma"]) nu = np.deg2rad(scan["nu"]) corr_factor = np.sin(gamma) * np.cos(nu) area_v = np.abs(area_v * corr_factor) area_s = np.abs(area_s * corr_factor) scan["area"] = (area_v, area_s)
def test_trapz(self): # Basic coverage test for the alias y = np.arange(4) x = 2**y assert_equal(trapezoid(y, x=x, dx=0.5, axis=0), trapz(y, x=x, dx=0.5, axis=0))
def evaluate(self, heatmap, img, target, do_insertion=True, do_deletion=True, cutoff=0.5): # noqa """# TODO to add docs Args: heatmap (Tensor): heatmap with shape (H, W) or (3, H, W). img (Tensor): image with shape (3, H, W). target (int): class index of the image. Returns: dict[str, Union[Tensor, np.array, float]]: a dictionary containing following fields - del_scores: ndarray, - ins_scores: - del_img: - ins_img: - ins_auc: - del_auc: """ # compress heatmap to 2D if needed if heatmap.ndim == 3: heatmap = heatmap.mean(0) heatmap = heatmap.mean(0) # sort pixel in attribution num_pixels = torch.numel(heatmap) _, indices = torch.topk(heatmap.flatten(), num_pixels) indices = np.unravel_index(indices.cpu().numpy(), heatmap.size()) blurred_img = self.gaussian_blurr(img) # apply deletion game deletion_scores = None deletion_auc = None num_pixels = int(cutoff * num_pixels) if do_deletion: deletion_perturber = PixelPerturber(img, blurred_img) deletion_scores = self._procedure_perturb(deletion_perturber, num_pixels, indices, target) # calculate AUC deletion_auc = trapezoid(deletion_scores, dx=1. / len(deletion_scores)) # apply insertion game insertion_scores = None insertion_auc = None if do_insertion: insertion_perturber = PixelPerturber(blurred_img, img) insertion_scores = self._procedure_perturb(insertion_perturber, num_pixels, indices, target) # calculate AUC insertion_auc = trapezoid(insertion_scores, dx=1. / len(insertion_scores)) # TODO check if it is necessary to convert the Tensors to np.ndarray return { "del_scores": deletion_scores, "ins_scores": insertion_scores, "ins_auc": insertion_auc, "del_auc": deletion_auc }
def evaluate(self, heatmap: torch.Tensor, image: torch.Tensor) -> dict: self.model.eval() # compress heatmap to 2D if needed if heatmap.ndim == 3: heatmap = heatmap.mean(0) # get 2d tile attribution perturber = GridPerturber(image, torch.zeros_like(image), self.tile_size) grid_heatmap = torch.zeros(perturber.get_grid_shape()) for r in range(grid_heatmap.shape[0]): for c in range(grid_heatmap.shape[1]): grid_heatmap[r][c] = heatmap[perturber.view.tile_slice( r, c)].sum() # sort tile in attribution num_pixels = torch.numel(grid_heatmap) _, indices = torch.topk(grid_heatmap.flatten(), num_pixels) indices = np.unravel_index(indices.cpu().numpy(), grid_heatmap.size()) _, reverse_indices = torch.topk(grid_heatmap.flatten(), num_pixels, largest=False) reverse_indices = np.unravel_index(reverse_indices.cpu().numpy(), grid_heatmap.size()) # TODO to make it compatible with multi-label classification setting # TODO to make baseline_score and morf_scores local variables rather than object attributes # get baseline score self.baseline_score = torch.nn.functional.softmax( self.model( image.unsqueeze(0).to(next( self.model.parameters()).device)))[:, self.target] self.baseline_score = self.baseline_score.detach().cpu().numpy() # apply deletion game using MoRF print("MoRF deletion") self.morf_scores = self._procedure_perturb(perturber, num_pixels, indices, self.img_history_morf) MoRF_img = perturber.get_current() # apply deletion game using LeRF perturber = GridPerturber(image, torch.zeros_like(image), self.tile_size) print("LeRF deletion") self.lerf_scores = self._procedure_perturb(perturber, num_pixels, reverse_indices, self.img_history_lerf) LeRF_img = perturber.get_current() #remove bias self.lerf_scores = self.lerf_scores - self.baseline_score self.morf_scores = self.morf_scores - self.baseline_score # calculate AUC lerf_auc = trapezoid(self.lerf_scores, dx=1. / float(len(self.lerf_scores))) morf_auc = trapezoid(self.morf_scores, dx=1. / float(len(self.morf_scores))) # deletion_img and insertion_img are final results, they are only used for debug purpose return { "MoRF_scores": self.morf_scores, "LeRF_scores": self.lerf_scores, "MoRF_img": MoRF_img, "LeRF_img": LeRF_img, "LeRF_auc": lerf_auc, "MoRF_auc": morf_auc, "MoRF_img_history": self.img_history_morf, "LeRF_img_history": self.img_history_lerf }
if galaxy in ["ngc7793", "ngc1566"]: ax_peak.scatter([peak_r], len(cat), c=bpl.color_cycle[3]) ax_peak.add_text( x=peak_r + 0.1, y=len(cat), text=galaxy.upper(), fontsize=12, ha="left", va="center", ) else: ax_peak.scatter([peak_r], len(cat), c=bpl.color_cycle[0]) # KL is done elementwise, then we integrate kl_values = special.kl_div(stacked_pdf, cat_pdf) kl_value = integrate.trapezoid(kl_values, radii_plot) ax.set_xscale("log") ax.set_limits(0.1, 25, 0, 1.0) ax.set_xticks([0.1, 1, 10]) ax.set_xticklabels(["0.1", "1", "10"]) ax.add_labels("$R_{eff}$ [pc]", "Normalized KDE Density") ax.easy_add_text( f"{galaxy.upper()}\n" f"N={len(cat)}\n" f"P={pvalue:.3g}\n" f"KL={kl_value:.3f}\n" "$R_{peak} = $" + f"{peak_r:.2f}pc", "upper left", ) # last axis isn't needed, we only have 31 galaxies
def auprc(self): prc = ( np.hstack((1, self.precision[::-1], 0)), np.hstack((0, self.recall[::-1], 1)), ) return trapezoid(*prc)
def auroc(self): roc = ( np.hstack((0, self.tpr[::-1], 1)), # true positive rate (y) np.hstack((0, self.fpr[::-1], 1)), # false positive rate (x) ) return trapezoid(*roc)
def get_auprc(self): scores = self.get_scores() res = np.array(list(map(prc_curve, scores.T, repeat(self.y)))) auc = np.array(list(map(lambda x: trapezoid(*x.T), res))) return auc
def plot_binary_performance(df, n=1): """ Plot ROC, PrecRec, F-score, Accuracy Pass perf df from calc.calc_binary_performance_measures Return summary stats """ roc_auc = integrate.trapezoid(y=df['tpr'], x=df['fpr']) prec_rec_auc = integrate.trapezoid(y=df['precision'], x=df['recall']) f, axs = plt.subplots(1, 4, figsize=(18, 5), sharex=False, sharey=False) _ = f.suptitle( ('Evaluations of Binary Classifier made by sweeping across ' + f'PPC quantiles\n(requires large n, here n={n})'), y=1.0) minpos = np.argmin(np.sqrt(df['fpr']**2 + (1 - df['tpr'])**2)) _ = axs[0].plot(df['fpr'], df['tpr'], lw=2, marker='d', alpha=0.8, label=f"ROC (auc={roc_auc:.2f})") _ = axs[0].plot((0, 1), (0, 1), '--', c='#cccccc', label='line of equiv') _ = axs[0].plot(df.loc[minpos, 'fpr'], df.loc[minpos, 'tpr'], lw=2, marker='D', color='w', markeredgewidth=1, markeredgecolor='b', markersize=9, label=f"Optimum ROC @ {minpos} pct") _ = axs[0].legend(loc='lower right') _ = axs[0].set(title='ROC curve', xlabel='FPR', ylabel='TPR', ylim=(0, 1)) _ = axs[1].plot(df['recall'], df['precision'], lw=2, marker='o', alpha=0.8, color='C3', label=f"PrecRec (auc={prec_rec_auc:.2f})") _ = axs[1].legend(loc='upper right') _ = axs[1].set(title='Precision Recall curve', ylim=(0, 1), xlabel='Recall', ylabel='Precision') f1_at = df['f1'].argmax() dfm = df.reset_index()[['pct', 'f0.5', 'f1', 'f2']].melt(id_vars='pct', var_name='f-measure', value_name='f-score') _ = sns.lineplot(x='pct', y='f-score', hue='f-measure', data=dfm, palette='Greens', lw=2, ax=axs[2]) _ = axs[2].plot(f1_at, df.loc[f1_at, 'f1'], lw=2, marker='D', color='w', markeredgewidth=1, markeredgecolor='b', markersize=9, label=f"Optimum F1 @ {f1_at} pct") _ = axs[2].legend(loc='upper left') _ = axs[2].set(title='F-scores across the PPC pcts' + f'\nBest F1 = {df.loc[f1_at, "f1"]:.3f} @ {f1_at} pct', xlabel='pct', ylabel='F-Score', ylim=(0, 1)) acc_at = df['accuracy'].argmax() _ = sns.lineplot(x='pct', y='accuracy', color='C1', data=df, lw=2, ax=axs[3]) _ = axs[3].text( x=0.04, y=0.04, s=('Class imbalance:' + f'\n0: {df["accuracy"].values[0]:.1%}' + f'\n1: {df["accuracy"].values[-1]:.1%}'), transform=axs[3].transAxes, ha='left', va='bottom', backgroundcolor='w', fontsize=10) _ = axs[3].set(title='Accuracy across the PPC pcts' + f'\nBest = {df.loc[acc_at, "accuracy"]:.1%} @ {acc_at} pct', xlabel='pct', ylabel='Accuracy', ylim=(0, 1)) f.tight_layout() return None
def f2(ts): return 4 * params.np_coef**2 * params.sigma * integrate.trapezoid([get_k(ti) * \ (pow(ti, 4) - pow(params.T0, 4)) for ti in ts], np.arange(0, params.l + params.h, params.h))
d_u__d_theta__entire_trajectory = solution_sensitivities_at_t # del_J__del_u has the shape (1, n_dim, n_time_points) - the leading 1 # (i.e. a proxy axis) is required in order to mimic the batch of row vectors del_J__del_u__entire_trajectory = (y_at_t - y_at_t_ref).reshape( (1, 2, time_points_inbetween)) d_j__d_theta__entire_trajectory = np.einsum( "EiN,iPN->EPN", del_J__del_u__entire_trajectory, d_u__d_theta__entire_trajectory, ) # Integrate d_j__d_theta over entire trajectory to obtain d_J__d_theta d_J__d_theta__entire_trajectory__forward = integrate.trapezoid( d_j__d_theta__entire_trajectory, t_discrete, axis=-1, ) ######################## ######################## ##### Adjoint Sensitivities ######################## ######################## ####### # (1.1) Using an additional trajectory that runs backwards alongside with # the backwards ODE for loss only at the end ####### time_adjoint__at_end = time.time_ns()
def integrate(ratios, quantiles): return trapezoid(ratios, quantiles)
def loss_function_entire_trajectory(y_at_t, theta): difference_at_t = y_at_t - y_at_t_ref quadratic_loss_at_t = 0.5 * np.einsum("iN,iN->N", difference_at_t, difference_at_t) return integrate.trapezoid(quadratic_loss_at_t, t_discrete, axis=-1)