def get_embeddings(loader, model):
zf, zh, labels = [], [], []
for x, y in tqdm(loader):
z_ = model.flow(x)[1]
zf.append(utils.tonp(z_))
labels.append(utils.tonp(y))
return np.concatenate(zf), np.concatenate(labels)
def get_embeddings(loader, model):
zf, zh, labels = [], [], []
for x, y in tqdm(loader):
z_ = model.flow(x)[1]
zf.append(utils.tonp(z_))
zh.append(utils.tonp(model.prior.flow(z_[:, -args.ssl_dim:, None, None], y)[1]))
labels.append(utils.tonp(y))
return np.concatenate(zf), np.concatenate(zh), np.concatenate(labels)
def plot_gmm(gmm, colors, ax):
pi = utils.tonp(torch.softmax(gmm.weights, 0))
for i, [covar, mean, w,
c] in enumerate(zip(gmm.covariances, gmm.means, pi, colors[1:])):
draw_ellipse(utils.tonp(covar),
utils.tonp(mean),
c,
ax,
alpha=w,
label=r'$\pi_{}$ = {:.3f}'.format(i + 1, w))
def get_metrics(model, loader):
logp, acc = [], []
for x, y in loader:
x = x.to(device)
log_det, z = model.flow(x)
log_prior_full = model.prior.log_prob_full(z)
pred = torch.softmax(log_prior_full, dim=1).argmax(1)
logp.append(utils.tonp(log_det + model.prior.log_prob(z)))
acc.append(utils.tonp(pred) == utils.tonp(y))
return np.mean(np.concatenate(logp)), np.mean(np.concatenate(acc))
def train():
logger.info('start building vocab data')
vocab = Vocab(hps.vocab_file, hps.vocab_size)
logger.info('end building vocab data')
logger.info('vocab size: %s' % vocab.size())
model = Model(vocab, hps)
if hps.use_cuda:
model = model.cuda()
if hps.restore is not None:
# raise ValueError('Noe data to restore')
model.load_state_dict(torch.load(hps.restore))
logger.info('----Start training----')
timer = Timer()
timer.start()
for step in range(hps.start_step, hps.num_iters + 1):
# Forward -------------------------------------------------------------
outputs = model(None, None, 'infer')
_, pred = torch.max(outputs, 1)
pred = tonp(pred)
logger.info('pred: %s' % restore_text(pred, vocab, [vocab.pad_id()]))
lap, _ = timer.lap('end')
print('pred time: %f', lap)
def plot(title='', data=None):
x, y = map(utils.tonp, [x_test, y_test])
z = flow.f(torch.FloatTensor(x).to(d))[0].detach().cpu().numpy()
plt.figure(figsize=(12, 12))
for t, c in zip(np.unique(y), colors):
idxs = (y == t)
plt.subplot(2, 2, 1)
plt.title('Z space (Data map)')
plt.scatter(z[idxs, 0], z[idxs, 1], c=[c], alpha=.6)
plt.subplot(2, 2, 2)
plt.title('X space (Data)')
plt.scatter(x[idxs, 0], x[idxs, 1], c=[c], alpha=.6)
z, y = flow.prior.sample((10000, ), labels=True)
x = flow.g(z).detach().cpu().numpy()
splot = plt.subplot(2, 2, 3)
plt.title('Z space (Prior samples)')
z = utils.tonp(z)
plt.scatter(z[:, 0], z[:, 1], s=5, c=colors[0], alpha=.0)
pi = utils.tonp(flow.prior.get_weights())
arg = np.arange(args.k_prior)
covs = utils.tonp(flow.prior.covariances)
mu = utils.tonp(torch.stack([m for m in flow.prior.means]))
for i, [covar, mean, w, c] in enumerate(
zip(covs[arg[:10]], mu[arg[:10]], pi[arg[:10]], colors[1:])):
draw_ellipse(covar,
mean,
c,
splot,
alpha=w,
label=r'$\pi_{}$ = {:.3f}'.format(i + 1, w))
splot.legend()
splot = plt.subplot(2, 2, 4)
plt.title('X space (Flow samples)')
plt.scatter(x[:, 0], x[:, 1], s=5, alpha=.2, c=colors[1:][y.clip(0, 9)])
plt.suptitle(title, size=25)
def auto_attacker2(self, team, role, opp, ball, side=0, tic=0):
"""Strategy for an attacker working with DQN."""
angle_to_ball = angle_to(team[role].pos, ball.pos)
angle_to_goal = angle_to(team[role].pos, goals[not side])
angle_ball_to_goal = angle_to(team[role].pos, goals[not side])
dist_ball_to_goal = dist(ball.pos, goals[not side])
dist_to_goal = dist(team[role].pos, goals[not side])
dist_to_ball = dist(team[role].pos, ball.pos)
print "angle_to_ball", angle_to_ball
print "angle_to_goal", angle_to_goal
print "angle_ball_to_goal", angle_ball_to_goal
print "dist_ball_to_goal", dist_ball_to_goal
print "dist_to_goal", dist_to_goal
print "dist_to_ball", dist_to_ball
# Decision tree
target = None
if abs(angle_diff(angle_to_goal, angle_ball_to_goal)) < 1 and \
dist_ball_to_goal < dist_to_goal:
# run to score!
target = ball.pos
print "GO KICK"
else:
if team[role].pos[0] < ball.pos[0]:
# go behind ball, aligned with goal
vec = vector_to(goals[not side], ball.pos)
vec = normalize_vector(vec, 0.7)
target = tonp(ball.pos) + vec
print "PREPARE TO KICK"
else:
# go behind goal
target = list(ball.pos)
if angle_to_ball > 0:
target[1] -= 0.5
else:
target[0] += 0.5
target[0] += 0.1
print "GO BEHIND BALL"
print team[role].pos, ball.pos, target
team[role].move_to(target)
if args.odenet:
model.set_nfe(0)
logits = model(x)
if args.odenet:
train_forward_nfe.update(model.get_nfe())
model.set_nfe(0)
loss = criterion(logits, y)
optimizer.zero_grad()
loss.backward()
optimizer.step()
if args.odenet:
train_backward_nfe.update(model.get_nfe())
model.set_nfe(0)
train_loss += loss.item() * x.size(0)
prediction = F.softmax(logits, dim=1).argmax(dim=1)
train_acc += np.sum(utils.tonp(prediction) == utils.tonp(y))
train_loss /= len(train_loader.sampler.indices)
train_acc /= len(train_loader.sampler.indices)
if epoch > args.warm:
scheduler.step(train_loss)
if epoch % args.log_each == 0 or epoch == 1 or epoch == args.epochs:
with torch.no_grad():
model.eval()
val_loss, val_acc, val_nfe = utils.get_classification_metrics(
model, val_loader, device, args.odenet)
# Save best model
if val_acc > best_val_acc:
best_val_acc = val_acc
torch.save(model.state_dict(),
def load_dataset(data,
train_bs,
test_bs,
num_examples=None,
data_root=DATA_ROOT,
shuffle=True,
seed=42,
supervised=-1,
logs_root='',
sup_sample_weight=-1,
sup_only=False,
device=None):
bits = None
sampler = None
if data in ['moons', 'circles']:
if data == 'moons':
x, y = datasets.make_moons(n_samples=int(num_examples * 1.5),
noise=0.1,
random_state=seed)
train_x, test_x, train_y, test_y = train_test_split(
x, y, train_size=num_examples, random_state=seed)
elif data == 'circles':
x, y = datasets.make_circles(n_samples=int(num_examples * 1.5),
noise=0.1,
factor=0.2,
random_state=seed)
train_x, test_x, train_y, test_y = train_test_split(
x, y, train_size=num_examples, random_state=seed)
if supervised not in [-1, len(train_y), 0]:
unsupervised_idxs, _ = train_test_split(np.arange(len(train_y)),
test_size=supervised,
stratify=train_y)
train_y[unsupervised_idxs] = -1
elif supervised == 0:
train_y[:] = -1
torch.save(
{
'train_x': train_x,
'train_y': train_y,
'test_x': test_x,
'test_y': test_y,
}, os.path.join(logs_root, 'data.torch'))
trainset = torch.utils.data.TensorDataset(
torch.FloatTensor(train_x[..., None, None]),
torch.LongTensor(train_y))
testset = torch.utils.data.TensorDataset(
torch.FloatTensor(test_x[..., None, None]),
torch.LongTensor(test_y))
data_shape = [2, 1, 1]
bits = np.nan
elif data == 'mnist':
train_transform = transforms.Compose([
transforms.ToTensor(),
UniformNoise(),
])
test_transform = transforms.Compose([
transforms.ToTensor(),
UniformNoise(),
])
trainset = torchvision.datasets.MNIST(root=data_root,
train=True,
download=True,
transform=train_transform)
testset = torchvision.datasets.MNIST(root=data_root,
train=False,
download=True,
transform=test_transform)
if num_examples != -1 and num_examples != len(
trainset) and num_examples is not None:
idxs, _ = train_test_split(np.arange(len(trainset)),
train_size=num_examples,
random_state=seed,
stratify=utils.tonp(trainset.targets))
trainset.data = trainset.data[idxs]
trainset.targets = trainset.targets[idxs]
if supervised == 0:
trainset.targets[:] = -1
elif supervised != -1:
unsupervised_idxs, _ = train_test_split(np.arange(
len(trainset.targets)),
test_size=supervised,
stratify=trainset.targets)
trainset.targets[unsupervised_idxs] = -1
if sup_only:
mask = trainset.targets != -1
trainset.targets = trainset.targets[mask]
trainset.data = trainset.data[mask]
data_shape = (1, 28, 28)
bits = 256
else:
raise NotImplementedError
nw = 2
if sup_sample_weight == -1:
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=train_bs,
shuffle=shuffle,
num_workers=nw,
pin_memory=True)
else:
sampler = ImbalancedDatasetSampler(trainset,
sup_weight=sup_sample_weight)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=train_bs,
sampler=sampler,
num_workers=nw,
pin_memory=True)
testloader = torch.utils.data.DataLoader(testset,
batch_size=test_bs,
shuffle=False,
num_workers=nw,
pin_memory=True)
return trainloader, testloader, data_shape, bits
# Create model
if args.prior == 'gmm':
if args.gmm_k == 1 and args.prior_train_algo == 'no':
prior = torch.distributions.MultivariateNormal(torch.zeros((2,)), torch.eye(2))
else:
prior = distributions.GMM(k=args.gmm_k, dim=2, normalize=args.prior_train_algo == 'GD')
else:
raise NotImplementedError
if args.model == 'toy':
flow = realnvp.get_toy_nvp(prior=prior, device=device)
else:
raise NotImplementedError
if args.gmm_init == 'GMM':
z = utils.batch_eval(lambda x: utils.tonp(flow.f(x[0].to(device))[0]), trainloader)
z = np.concatenate(z)
gmm = GaussianMixture(n_components=args.gmm_k, covariance_type=args.gmm_cov).fit(z)
for i in range(args.gmm_k):
flow.prior.means[i].data = torch.FloatTensor(gmm.means_[i]).to(device)
flow.prior.set_covariance(i, torch.FloatTensor(gmm.covariances_[i]).to(device))
flow.prior.weights.data = torch.FloatTensor(np.log(gmm.weights_)).to(device)
torch.save(flow.state_dict(), os.path.join('../data/', 'model.torch'))
if args.gmm_k == 1:
pass
elif args.prior_train_algo == 'no':
for p in flow.prior.parameters():
p.requires_grad = False
log_prior[y != -1] = model.prior.log_prob(z[y != -1],
y=y[y != -1].to(
x.device))
elbo = log_det + log_prior
weights = torch.ones((elbo.size(0), )).to(elbo)
weights[y != -1] = args.sup_weight
weights /= weights.sum()
gen_loss = -(elbo * weights.detach()).sum()
cl_loss = 0
if n_sup != 0:
logp_full = model.prior.log_prob_full(z[y != -1])
prediction = logp_full
train_acc.add(utils.tonp(prediction.argmax(1).to(y) == y[y != -1]))
if args.cl_weight != 0:
cl_loss = F.cross_entropy(prediction,
y[y != -1].to(prediction.device),
reduction='none')
train_cl.add(utils.tonp(cl_loss))
cl_loss = cl_loss.mean()
loss = gen_loss + args.cl_weight * cl_loss
optimizer.zero_grad()
loss.backward()
optimizer.step()
train_elbo.add(utils.tonp(elbo))
train_loss += loss.item() * x.size(0)
def get_logp(model, loader):
logp = []
for x, _ in loader:
x = x.to(device)
logp.append(utils.tonp(model.log_prob(x)))
return np.concatenate(logp)
def one_sample(self, labels=False):
k = np.random.choice(len(self.weights), p=utils.tonp(self.weights))
if labels:
return self.base_ditributions[k].sample(), k
return self.base_ditributions[k].sample()
encoder = vae_module.Encoder5x5(args.z_dim, args.hidden_dim)
vae = vae_module.VAE(encoder, decoder, device=device)
vae.load_state_dict(torch.load(args.model))
# Reconstructions
n, m = 10, 5
np.random.seed(42)
fig, axes = plt.subplots(figsize=(15, 12), nrows=n, ncols=m)
img_idxs = np.random.randint(0, len(data), size=(n * m))
for i, ax in enumerate(axes.flat):
c = data[img_idxs[i]][np.newaxis]
inp = torch.FloatTensor(c).to(device)
_, [rec, _] = vae(inp)
rec = tonp(rec)
c = np.concatenate([c, rec], 3)[0, 0]
sns.heatmap(c, ax=ax)
ax.axis('off')
plt.savefig(os.path.join(args.log_dir, 'reconstruction'), dpi=200)
plt.clf()
# Samples
n, m = 10, 10
z = torch.randn(n * m, args.z_dim, 1, 1).to(device)
mu, var = vae.decode(z)
x = tonp(mu)[:, 0]
fig, axes = plt.subplots(figsize=(5, 5), nrows=n, ncols=m)
def process_try_except(self, lazy_df):
accumulator = self.accumulator.identity()
df = MaskedLazyDataFrame.from_lazy(lazy_df)
sample_name = df['dataset']
accumulator['cutflow'][f'{sample_name}_start'] += df.shape[0]
# compute PU weights
if sample_name.startswith('Single'):
df['weight'] = np.ones(df.shape[0])
else:
key = f'pu_{sample_name}'
if key not in self.weights_lookup:
key = 'pu_mc'
if key not in self.weights_lookup:
print('Probably this is just a test, assigning a random PU weight')
key = list(self.weights_lookup.keys())[0]
central = self.weights_lookup['pu_data'](df['pu_trueInteraction']) / self.weights_lookup[key](df['pu_trueInteraction'])
up = self.weights_lookup['pu_data_up'](df['pu_trueInteraction']) / self.weights_lookup[key](df['pu_trueInteraction'])
down = self.weights_lookup['pu_data_down'](df['pu_trueInteraction']) / self.weights_lookup[key](df['pu_trueInteraction'])
df['weight'] = central
df['pileup_up'] = up / central
df['pileup_down'] = down / central
# Make objects (electrons, muons, jets, SVs...) here
df['muons'] = objects.make_muons(df)
df['svs'] = objects.make_svs(df)
df['jets'] = objects.make_jets(df)
#count loose muons (- tight)
df['nLooseMu'] = df.muons.isLoose.sum() - 1
# Get prompt muon and select events
prompt_mu_mask = (df.muons.p4.pt > 25) & (np.abs(df.muons.p4.eta) < 2.5) & (df.muons.dbIso < 0.1) & df.muons.isTight
all_prompt_mus = df['muons'][prompt_mu_mask]
df['prompt_mu'] = all_prompt_mus[:,:1] # pick only the first one
trig_to_use = 'passIsoMu27All' if '2017' in self.jobid else 'passIsoMu24'
trig_and_prompt = df[trig_to_use] & (all_prompt_mus.counts > 0)
accumulator['cutflow'][f'{sample_name}_trigg&promptMu'] += trig_and_prompt.sum()
# Get trailing muon, here we need some gym due to broadcasting issues
displ_mu_mask = (df['muons'].p4.pt > 5) & (np.abs(df['muons'].p4.eta) < 2.5) & df['muons'].isLoose
# check that we are not selecting the same muon
lft, rht = df['muons'].p4.cross(df['prompt_mu'].p4, nested = True).unzip() # make combinations
min_dr = lft.delta_r(rht).min() # min DR
displ_mu_mask = trig_and_prompt & displ_mu_mask & (min_dr > 0.0000001)
all_displ_mu = df['muons'][displ_mu_mask]
# select SVs
good_svs = df['svs'][df['svs'].pt > 0] \
if (df['svs'].counts > 0).any() else \
df['svs']
# make skimming and attach trailing mu and sv
presel = trig_and_prompt & (all_displ_mu.counts > 0) & (good_svs.counts > 0)
df['n_displaced_mu'] = all_displ_mu.counts
df['second_mu'] = all_displ_mu[:,:1]
df['goodsv'] = good_svs[:,:1]
skim = df[presel]
accumulator['cutflow'][f'{sample_name}_skimming'] += presel.sum()
# flatten objects to avoid messing around
skim['prompt_mu'] = skim['prompt_mu'].flatten()
skim['second_mu'] = skim['second_mu'].flatten()
skim['goodsv'] = skim['goodsv'].flatten()
# select and match jet to the second muon
jets = skim['jets'] # just a shortcut to avoid writing it constantly
# jet ID selection by bins, useful given that muons are only up to 2.4?
selection_eta_bins = [
# |eta| < 2.4
(np.abs(jets.p4.eta) <= 2.4) & \
(jets.charHadEnFrac > 0.) & (jets.chargedMult > 0) & (jets.charEmEnFrac <= 0.99),
# |eta| < 2.7
(np.abs(jets.p4.eta) <= 2.7) & (jets.neutHadEnFrac <= 0.9) & \
(jets.neutEmEnFrac <= 0.90) & ((jets.chargedMult + jets.neutMult) >= 1),
# |eta| < 3.0
(np.abs(jets.p4.eta) <= 2.7) & (jets.neutHadEnFrac <= 0.98) & \
(jets.neutEmEnFrac <= 0.01) & (jets.neutMult >= 2),
# any eta \_(-.-)_/
(jets.neutEmEnFrac <= 0.9) & (jets.neutMult >= 10),
]
# compute the or of the masks
jet_id = reduce(lambda x, y: x | y, selection_eta_bins)
# compute DR w.r.t. the prompt and second muon
dr_promt = utils.tonp(
skim['prompt_mu'].p4.delta_r(jets.p4)
)
dr_second = utils.tonp(
skim['second_mu'].p4.delta_r(jets.p4)
)
selection_dr = (dr_promt >= 0.4) & (dr_second <= 0.7) & \
(jets.p4.pt > 20) & jet_id
selected_jets = jets[selection_dr]
selected_dr_second = dr_second[selection_dr]
##skim['n_selected_jets'] = None TO ADD when we understand what Mohamed did
# pick the closest jet, keep jaggedness to avoid
# messing up skim. This BADLY needs awkward v2.0
# to fix this mess
min_dr = selected_dr_second.argmin()
matched_jets = selected_jets[min_dr]
at_least_one_jet = (selected_dr_second.count() > 0)
# make preselection variables and cuts
skim['m1_vtx_mass'] = (skim.prompt_mu.p4 + skim.goodsv.p4).mass
skim['ll_mass'] = (skim.prompt_mu.p4 + skim.second_mu.p4).mass
skim['ll_dr'] = skim.prompt_mu.p4.delta_r(skim.second_mu.p4)
#transverse mass
skim['tmass_goodsv'] = np.sqrt(pow(skim.goodsv.p4.pt + skim.pfMet_pt,2) - \
pow(skim.goodsv.p4.x + skim.pfMet_px,2) - \
pow(skim.goodsv.p4.y + skim.pfMet_py,2))
skim['tmass_promptmu'] = np.sqrt(pow(skim.prompt_mu.p4.pt + skim.pfMet_pt,2) - \
pow(skim.prompt_mu.p4.x + skim.pfMet_px,2) - \
pow(skim.prompt_mu.p4.y + skim.pfMet_py,2))
svPlusmu_p4 = skim.goodsv.p4 + skim.prompt_mu.p4
skim['tmass_svmu'] = np.sqrt(pow(svPlusmu_p4.pt + skim.pfMet_pt,2) - \
pow(svPlusmu_p4.x + skim.pfMet_px,2) - \
pow(svPlusmu_p4.y + skim.pfMet_py,2))
skim['dimu_deltaphi'] = np.abs(skim.prompt_mu.p4.delta_phi(skim.second_mu.p4))
goodsv_pt2 = (skim.goodsv.position.cross(skim.goodsv.p3).mag2)/(skim.goodsv.position.mag2)
skim['mass_corr'] = np.sqrt(skim.goodsv.p4.mass * skim.goodsv.p4.mass + goodsv_pt2) + \
np.sqrt(goodsv_pt2)
# make preslection cut
preselection_mask = (skim.prompt_mu.absdxy < 0.005) & (skim.prompt_mu.absdz < 0.1) & \
(skim.second_mu.absdxy > 0.02) & \
(0.3 < skim.ll_dr) & at_least_one_jet
#(40 < skim.m1_vtx_mass) & (skim.m1_vtx_mass < 90) & \ # removed from preselection_mask
preselection = skim[preselection_mask]
matched_jet = matched_jets[preselection_mask][:,0] # cannot attach to preselection for some reason FIXME!
selection_mask = (1 < preselection.ll_dr) & (preselection.ll_dr < 5) & \
(preselection.jet_pt.counts > 0) & (preselection.jet_pt.max() > 20)
#(20 < preselection.ll_mass) & (preselection.ll_mass < 85) & \ # removed from selection_mask
same_sign = (preselection.prompt_mu.charge * preselection.second_mu.charge) >0.
opp_sign = np.invert(same_sign)
preselection['isOS'] = opp_sign
accumulator['cutflow'][f'{sample_name}_preselection'] += preselection.shape[0]
accumulator['cutflow'][f'{sample_name}_selection'] += selection_mask.sum()
#print(preselection.shape[0], preselection['weight'].sum())
# fill preselection histograms
for category, mask in [
('preselection_SS', same_sign),
('preselection_OS', opp_sign),
('selection_SS', selection_mask & same_sign),
('selection_OS', selection_mask & opp_sign),]:
masked_df = preselection[mask]
masked_jets = matched_jet[mask]
accumulator[category]['prompt_pt' ].fill(
weight = masked_df['weight'], sample = sample_name,
pt = utils.tonp(masked_df.prompt_mu.p4.pt)
)
accumulator[category]['diplaced_pt'].fill(
weight = masked_df['weight'], sample = sample_name,
pt = utils.tonp(masked_df.second_mu.p4.pt)
)
accumulator[category]['di_mu_M' ].fill(
weight = masked_df['weight'], sample = sample_name,
mass = utils.tonp(masked_df['ll_mass'])
)
accumulator[category]['di_mu_DR' ].fill(
weight = masked_df['weight'], sample = sample_name,
dr = utils.tonp(masked_df.ll_dr)
)
accumulator[category]['sv_lxy' ].fill(
weight = masked_df['weight'], sample = sample_name,
lxy = utils.tonp(masked_df['goodsv']['lxy'])
)
accumulator[category]['sv_mass' ].fill(
weight = masked_df['weight'], sample = sample_name,
mass = utils.tonp(masked_df.goodsv.p4.mass)
)
accumulator[category]['m1_vtx_mass' ].fill(
weight = masked_df['weight'], sample = sample_name,
mass = utils.tonp(masked_df['m1_vtx_mass'])
)
if category == 'preselection_SS' or category == 'preselection_OS':
accumulator[category]['sv_tM'].fill(
weight = masked_df['weight'], sample = sample_name,
mass = utils.tonp(masked_df.tmass_goodsv)
)
accumulator[category]['mu_tM'].fill(
weight = masked_df['weight'], sample = sample_name,
mass = utils.tonp(masked_df.tmass_promptmu)
)
accumulator[category]['musv_tM'].fill(
weight = masked_df['weight'], sample = sample_name,
mass = utils.tonp(masked_df.tmass_svmu)
)
accumulator[category]['corr_M'].fill(
weight = masked_df['weight'], sample = sample_name,
mass = utils.tonp(masked_df.mass_corr)
)
if category.startswith('selection'):
# variables for CNN
accumulator['columns'][sample_name]['isOS'] += utils.tonp(masked_df['isOS'])
accumulator['columns'][sample_name]['pu_weight'] += utils.tonp(masked_df['weight'])
accumulator['columns'][sample_name]['m1_vtx_mass'] += utils.tonp(masked_df['m1_vtx_mass'])
accumulator['columns'][sample_name]['mu2_absdxy'] += utils.tonp(masked_df['second_mu']['absdxy'])
accumulator['columns'][sample_name]['mu2_absdz'] += utils.tonp(masked_df['second_mu']['absdz'])
accumulator['columns'][sample_name]['mu2_phi'] += utils.tonp(masked_df['second_mu'].p4.phi)
accumulator['columns'][sample_name]['mu2_ptBT'] += utils.tonp(masked_df['second_mu']['pt_BT'])
accumulator['columns'][sample_name]['mu2_etaBT'] += utils.tonp(masked_df['second_mu']['eta_BT'])
accumulator['columns'][sample_name]['mu2_absdxySig'] += utils.tonp(masked_df['second_mu']['absdxySig'])
accumulator['columns'][sample_name]['mu2_absdzSig'] += utils.tonp(masked_df['second_mu']['absdzSig'])
accumulator['columns'][sample_name]['mu2_deltaBeta'] += utils.tonp(masked_df['second_mu']['deltaBeta'])
accumulator['columns'][sample_name]['mu2_nDof'] += utils.tonp(masked_df['second_mu']['nDof'])
accumulator['columns'][sample_name]['mu2_timeAtIpInOut'] += utils.tonp(masked_df['second_mu']['timeAtIpInOut'])
accumulator['columns'][sample_name]['mu2_timeAtIpInOutErr'] += utils.tonp(masked_df['second_mu']['timeAtIpInOutErr'])
accumulator['columns'][sample_name]['mu2_timeAtIpOutIn'] += utils.tonp(masked_df['second_mu']['timeAtIpOutIn'])
accumulator['columns'][sample_name]['mu2_timeAtIpOutInErr'] += utils.tonp(masked_df['second_mu']['timeAtIpOutInErr'])
accumulator['columns'][sample_name]['mu2_segmentComp'] += utils.tonp(masked_df['second_mu']['segmentComp'])
accumulator['columns'][sample_name]['mu2_trkKink'] += utils.tonp(masked_df['second_mu']['trkKink'])
accumulator['columns'][sample_name]['mu2_chi2LocalPosition'] += utils.tonp(masked_df['second_mu']['chi2LocalPosition'])
accumulator['columns'][sample_name]['mu2_rhoRelIso'] += utils.tonp(masked_df['second_mu']['rho_rel_iso'])
accumulator['columns'][sample_name]['sv_mass'] += utils.tonp(masked_df['goodsv'].p4.mass)
accumulator['columns'][sample_name]['sv_pt'] += utils.tonp(masked_df['goodsv'].p4.pt)
accumulator['columns'][sample_name]['sv_lxySig'] += utils.tonp(masked_df['goodsv']['lxySig'])
accumulator['columns'][sample_name]['sv_lxyzSig'] += utils.tonp(masked_df['goodsv']['lxyzSig'])
accumulator['columns'][sample_name]['sv_lxy'] += utils.tonp(masked_df['goodsv']['lxy'])
accumulator['columns'][sample_name]['sv_lxyz'] += utils.tonp(masked_df['goodsv']['lxyz'])
accumulator['columns'][sample_name]['sv_angle3D'] += utils.tonp(masked_df['goodsv']['angle3D'])
accumulator['columns'][sample_name]['sv_angle2D'] += utils.tonp(masked_df['goodsv']['angle2D'])
accumulator['columns'][sample_name]['sv_gamma'] += utils.tonp(masked_df['goodsv']['gamma'])
accumulator['columns'][sample_name]['sv_chi2'] += utils.tonp(masked_df['goodsv']['chi2'])
accumulator['columns'][sample_name]['sv_sum_tracks_dxySig'] += utils.tonp(masked_df['goodsv']['sum_tracks_dxySig']).astype(np.float64)
accumulator['columns'][sample_name]['mujet_eta'] += utils.tonp(masked_jets.p4.eta)
accumulator['columns'][sample_name]['mujet_phi'] += utils.tonp(masked_jets.p4.phi)
accumulator['columns'][sample_name]['mujet_neutHadEnFrac'] += utils.tonp(masked_jets['neutHadEnFrac'])
accumulator['columns'][sample_name]['mujet_neutEmEnFrac'] += utils.tonp(masked_jets['neutEmEnFrac'])
accumulator['columns'][sample_name]['mujet_charHadEnFrac'] += utils.tonp(masked_jets['charHadEnFrac'])
accumulator['columns'][sample_name]['mujet_charEmEnFrac'] += utils.tonp(masked_jets['charEmEnFrac'])
accumulator['columns'][sample_name]['mujet_neutMult'] += utils.tonp(masked_jets['neutMult'])
accumulator['columns'][sample_name]['mujet_smeared_pt'] += utils.tonp(masked_jets['smeared_pt'])
accumulator['columns'][sample_name]['mujet_dCsv_bb'] += utils.tonp(masked_jets['dCsv_bb'])
accumulator['columns'][sample_name]['mujet_charEmEn'] += utils.tonp(masked_jets['charEmEn'])
accumulator['columns'][sample_name]['mujet_charHadEn'] += utils.tonp(masked_jets['charHadEn'])
accumulator['columns'][sample_name]['mujet_charMuEn'] += utils.tonp(masked_jets['charMuEn'])
accumulator['columns'][sample_name]['mujet_charMuEnFrac'] += utils.tonp(masked_jets['charMuEnFrac'])
accumulator['columns'][sample_name]['mujet_muonEn'] += utils.tonp(masked_jets['muonEn'])
accumulator['columns'][sample_name]['mujet_muonEnFrac'] += utils.tonp(masked_jets['muonEnFrac'])
accumulator['columns'][sample_name]['mujet_muonEn'] += utils.tonp(masked_jets['muonEn'])
accumulator['columns'][sample_name]['mujet_muonEnFrac'] += utils.tonp(masked_jets['muonEnFrac'])
accumulator['columns'][sample_name]['mujet_neutEmEn'] += utils.tonp(masked_jets['neutEmEn'])
accumulator['columns'][sample_name]['mujet_neutHadEn'] += utils.tonp(masked_jets['neutHadEn'])
accumulator['columns'][sample_name]['sv_tM'] += utils.tonp(masked_df['tmass_goodsv'])
accumulator['columns'][sample_name]['mu1_tM'] += utils.tonp(masked_df['tmass_promptmu'])
accumulator['columns'][sample_name]['mu2_tM'] += utils.tonp(masked_df['tmass_svmu'])
accumulator['columns'][sample_name]['corr_M'] += utils.tonp(masked_df['mass_corr'])
accumulator['columns'][sample_name]['dimu_deltaphi'] += utils.tonp(masked_df['dimu_deltaphi'])
accumulator['columns'][sample_name]['dimu_mass'] += utils.tonp(masked_df['ll_mass'])
accumulator['columns'][sample_name]['dimu_dr'] += utils.tonp(masked_df['ll_dr'])
accumulator['columns'][sample_name]['nLooseMu'] += utils.tonp(masked_df['nLooseMu'])
accumulator['columns'][sample_name]['nDisplacedMu'] += utils.tonp(masked_df['n_displaced_mu'])
#######
accumulator['columns'][sample_name]['sv_tracks_charge'] += utils.tonp(masked_df['goodsv']['tracks_charge'])
accumulator['columns'][sample_name]['sv_tracks_eta'] += utils.tonp(masked_df['goodsv']['tracks_eta'] )
accumulator['columns'][sample_name]['sv_tracks_phi'] += utils.tonp(masked_df['goodsv']['tracks_phi'])
accumulator['columns'][sample_name]['sv_tracks_pt'] += utils.tonp(masked_df['goodsv']['tracks_pt'])
accumulator['columns'][sample_name]['sv_tracks_p'] += utils.tonp(masked_df['goodsv']['tracks_p'])
accumulator['columns'][sample_name]['sv_tracks_dxySig'] += utils.tonp(masked_df['goodsv']['tracks_dxySig'])
accumulator['columns'][sample_name]['sv_tracks_dxy'] += utils.tonp(masked_df['goodsv']['tracks_dxy'])
accumulator['columns'][sample_name]['sv_tracks_dxyz'] += utils.tonp(masked_df['goodsv']['tracks_dxyz'])
return accumulator
