def test_EFN_masking(mask_val):
n, m1, m2 = (50, 10, 20)
input_dim = 3
X_train = [np.random.rand(n, m1), np.random.rand(n, m1, input_dim)]
y_train = np.random.rand(n, 2)
efn = archs.EFN(input_dim=input_dim,
Phi_sizes=[10],
F_sizes=[10],
mask_val=mask_val)
efn.fit(X_train, y_train, epochs=1)
X_test = [np.random.rand(n, m2), np.random.rand(n, m2, input_dim)]
X_test_mask = [
np.concatenate((X_test[0], mask_val * np.ones((n, 5))), axis=1),
np.concatenate((X_test[1], mask_val * np.ones((n, 5, input_dim))),
axis=1)
]
assert epsilon_diff(efn.predict(X_test), efn.predict(X_test_mask), 10**-15)
kf = K.function(inputs=efn.inputs, outputs=efn.latent)
pure_mask = kf([0 * X_test[0] + mask_val, 0 * X_test[1] + mask_val])[0]
assert epsilon_diff(pure_mask, 0, 10**-15)
def test_measure_hadrdot_ptyphi(event, beta, theta_eps, kappa, normed,
kappa_normed_behavior):
if normed and kappa == 'pf':
pytest.skip()
pTs = event[:, 0]
ps = np.asarray([
pT * np.asarray(
[np.cosh(y), np.cos(phi),
np.sin(phi), np.sinh(y)]) for (pT, y, phi) in event
])
# compute using the energyflow package
hmeas = ef.Measure('hadrdot', beta, kappa, normed, 'ptyphim', True,
kappa_normed_behavior)
hzs, hthetas = hmeas.evaluate(event)
# compute naively
norm = 1 if not normed else (np.sum(pTs**kappa) if kappa_normed_behavior
== 'orig' else np.sum(pTs)**kappa)
zs = (pTs**kappa) / norm if kappa != 'pf' else np.ones(len(pTs))
phats = np.asarray(
[p / (pT if kappa != 'pf' else 1) for p, pT in zip(ps, pTs)])
thetas = np.asarray([[
2 * abs(phti[0] * phtj[0] - np.dot(phti[1:], phtj[1:]))
for phti in phats
] for phtj in phats])**(beta / 2)
assert epsilon_diff(hzs, zs, 10**-13)
assert epsilon_diff(hthetas, thetas, 10**-theta_eps)
def test_emd_equivalence(M1, M2, norm, R):
gdim = 2
events1 = np.random.rand(nev, M1, gdim + 1)
events2 = np.random.rand(nev, M2, gdim + 1)
# test two different sets
emds1 = np.zeros((nev, nev))
for i, ev1 in enumerate(events1):
for j, ev2 in enumerate(events2):
emds1[i, j] = emd.emd(ev1, ev2, R=R, norm=norm, gdim=gdim)
emds2 = emd.emds(events1,
events2,
R=R,
norm=norm,
verbose=0,
n_jobs=1,
gdim=gdim)
assert epsilon_diff(emds1, emds2, 10**-12)
# test same set
emds1 = np.zeros((nev, nev))
for i, ev1 in enumerate(events1):
for j in range(i):
emds1[i, j] = emd.emd(ev1, events1[j], R=R, norm=norm, gdim=gdim)
emds1 += emds1.T
emds2 = emd.emds(events1, R=R, norm=norm, verbose=0, n_jobs=1, gdim=gdim)
assert epsilon_diff(emds1, emds2, 10**-12)
def test_periodic_phi(gdim, M):
events = np.random.rand(nev, M, 1 + gdim)
for phi_col in range(1, gdim + 1):
emds1 = emd.emds_pot(events, R=1.0, gdim=gdim, n_jobs=1, verbose=0)
events_c = np.copy(events)
events_c[:, :, phi_col] += 2 * np.pi * np.random.randint(
-10, 10, size=(nev, M))
emds2 = emd.emds_pot(events_c,
R=1.0,
gdim=gdim,
periodic_phi=True,
phi_col=phi_col,
n_jobs=1,
verbose=0)
assert epsilon_diff(emds1, emds2, 10**-12)
ev1 = np.random.rand(10, 1 + gdim) * 4 * np.pi
ev2 = np.random.rand(20, 1 + gdim) * 4 * np.pi
thetaw = np.zeros((len(ev1), len(ev2)))
thetar = np.zeros((len(ev1), len(ev2)))
for i, p1 in enumerate(ev1):
for j, p2 in enumerate(ev2):
dw, dr = 0., 0.
for m, (k1, k2) in enumerate(zip(p1, p2)):
if m == 0:
continue
elif m == phi_col:
dw += (k1 - k2)**2
dr += np.min([
abs(k1 - (k2 + 2 * np.pi * n))
for n in range(-3, 3)
])**2
else:
dw += (k1 - k2)**2
dr += (k1 - k2)**2
thetaw[i, j] = np.sqrt(dw)
thetar[i, j] = np.sqrt(dr)
zs1 = np.ascontiguousarray(ev1[:, 0] / np.sum(ev1[:, 0]))
zs2 = np.ascontiguousarray(ev2[:, 0] / np.sum(ev2[:, 0]))
ot_w, ot_r = ot.emd2(zs1, zs2, thetaw), ot.emd2(zs1, zs2, thetar)
ef_w = emd.emd_pot(ev1,
ev2,
norm=True,
gdim=gdim,
periodic_phi=False,
phi_col=phi_col)
ef_r = emd.emd_pot(ev1,
ev2,
norm=True,
gdim=gdim,
periodic_phi=True,
phi_col=phi_col)
assert epsilon_diff(ot_w, ef_w, 10**-14)
assert epsilon_diff(ot_r, ef_r, 10**-14)
def test_measure_list_input(measure, event, check_input):
meas = ef.Measure(measure, check_input=check_input)
list_event = event.tolist()
nd0, nd1 = meas.evaluate(event)
try:
list0, list1 = meas.evaluate(list_event)
except:
assert not check_input
else:
assert check_input
assert epsilon_diff(nd0, list0, 10**-14)
assert epsilon_diff(nd1, list1, 10**-14)
def test_C2D2C3(measure, beta, normed):
# skip the efm measures for beta other than 2
if ('efm' in measure) and (beta != 2):
pytest.skip('only beta=2 can use efm measure')
# generate a random event with 10 particles
event = ef.gen_random_events(1, 10, dim=4)
# specify the relevant graphs and EFPs to compute C1, D2, C3
line = ef.EFP([(0, 1)],
measure=measure,
coords='epxpypz',
beta=beta,
normed=True)(event)
triangle = ef.EFP([(0, 1), (0, 2), (1, 2)],
measure=measure,
coords='epxpypz',
beta=beta,
normed=True)(event)
kite = ef.EFP([(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)],
measure=measure,
coords='epxpypz',
beta=beta,
normed=True)(event)
# determine the observables
C2val = triangle / line**2
D2val = triangle / line**3
C3val = kite * line / triangle**2
for strassen in [True, False]:
# skip strassen for EFM measures and hadr
if ('efm' in measure or measure == 'hadr') and strassen:
continue
D2 = ef.obs.D2(measure=measure,
beta=beta,
strassen=strassen,
normed=normed,
coords='epxpypz')
assert epsilon_diff(D2(event), D2val, 10**-10)
C2 = ef.obs.C2(measure=measure,
beta=beta,
strassen=strassen,
normed=normed,
coords='epxpypz')
assert epsilon_diff(C2(event), C2val, 10**-10)
C3 = ef.obs.C3(measure=measure, beta=beta, coords='epxpypz')
assert epsilon_diff(C3(event), C3val, 10**-10)
def test_measure_hadr_ptyphi(pts, ys, phis, beta, kappa, normed):
M = len(pts)
# compute using the energyflow package
hmeas = ef.Measure('hadr', beta, kappa, normed, 'ptyphim', True)
hzs, hthetas = hmeas.evaluate(np.vstack((pts,ys,phis)).T)
# compute naively
norm = 1 if not normed else np.sum(pts**kappa)
zs = (pts**kappa)/norm
thetas = np.asarray([[(ys[i]-ys[j])**2 + min(abs(phis[i]-phis[j]), 2*np.pi-abs(phis[i]-phis[j]))**2
for i in range(M)] for j in range(M)])**(beta/2)
assert epsilon_diff(hzs, zs, 10**-13)
assert epsilon_diff(hthetas, thetas, 10**-13)
def test_measure_ee(event, beta, theta_eps, kappa, normed, kappa_normed_behavior):
if kappa == 'pf' and normed:
pytest.skip()
Es = event[:,0]
emeas = ef.Measure('ee', beta, kappa, normed, 'epxpypz', True, kappa_normed_behavior)
ezs, ethetas = emeas.evaluate(event)
# compute naively
norm = 1 if not normed else (np.sum(Es**kappa) if kappa_normed_behavior == 'orig' else np.sum(Es)**kappa)
zs = (Es**kappa)/norm if kappa != 'pf' else np.ones(len(Es))
phats = np.asarray([p/(E if kappa != 'pf' else 1) for p,E in zip(event,Es)])
thetas = np.asarray([[2*abs(phti[0]*phtj[0]-np.dot(phti[1:],phtj[1:])) for phti in phats] for phtj in phats])**(beta/2)
assert epsilon_diff(ezs, zs, 10**-13)
assert epsilon_diff(ethetas, thetas, 10**-theta_eps)
def test_measure_hadr_p4s(event, beta, kappa, normed):
M = len(event)
pTs = np.sqrt(event[:,1]**2 + event[:,2]**2)
ys = 0.5*np.log((event[:,0] + event[:,3])/(event[:,0] - event[:,3]))
phis = np.arctan2(event[:,2], event[:,1])
# compute using the energyflow package
hmeas = ef.Measure('hadr', beta, kappa, normed, 'epxpypz', True)
hzs, hthetas = hmeas.evaluate(event)
# compute naively
norm = 1 if not normed else np.sum(pTs**kappa)
zs = (pTs**kappa)/norm
thetas = np.asarray([[(ys[i]-ys[j])**2 + min(abs(phis[i]-phis[j]), 2*np.pi-abs(phis[i]-phis[j]))**2
for i in range(M)] for j in range(M)])**(beta/2)
assert epsilon_diff(hzs, zs, 10**-12)
assert epsilon_diff(hthetas, thetas, 10**-12)
def test_n_jobs(n_jobs, M, norm, R):
events = np.random.rand(nev, M, 3)
emds1 = np.zeros((nev, nev))
for i, ev1 in enumerate(events):
for j in range(i):
emds1[i, j] = emd.emd(ev1, events[j], R=R, norm=norm)
emds1 += emds1.T
emds2 = emd.emds(events, R=R, norm=norm, verbose=0, n_jobs=n_jobs)
assert epsilon_diff(emds1, emds2, 10**-12)
def test_measure_hadrdot_p4s(event, beta, theta_eps, kappa, normed):
if normed and kappa == 'pf':
pytest.skip()
pTs = np.sqrt(event[:,1]**2 + event[:,2]**2)
ps = event
# compute using the energyflow package
hmeas = ef.Measure('hadrdot', beta, kappa, normed, 'epxpypz', True)
hzs, hthetas = hmeas.evaluate(event)
# compute naively
norm = 1 if not normed else np.sum(pTs**kappa)
zs = (pTs**kappa)/norm if kappa != 'pf' else np.ones(len(pTs))
phats = np.asarray([p/(pT if kappa != 'pf' else 1) for p,pT in zip(ps,pTs)])
thetas = np.asarray([[2*abs(phti[0]*phtj[0]-np.dot(phti[1:],phtj[1:])) for phti in phats] for phtj in phats])**(beta/2)
assert epsilon_diff(hzs, zs, 10**-13)
assert epsilon_diff(hthetas, thetas, 10**-theta_eps)
def test_gdim(gdim, evdim, M, norm, R):
if R < np.sqrt(gdim) / 2:
pytest.skip('R too small')
events = np.random.rand(nev, M, 1 + evdim)
emds1 = emd.emds(events, gdim=gdim, norm=norm, R=R, n_jobs=1, verbose=0)
emds2 = emd.emds(events[:, :, :1 + gdim],
gdim=100,
norm=norm,
R=R,
n_jobs=1,
verbose=0)
assert epsilon_diff(emds1, emds2, 10**-13)
def test_PFN_masking(mask_val):
n, m1, m2 = (50, 10, 20)
input_dim = 3
X_train = np.random.rand(n, m1, input_dim)
y_train = np.random.rand(n, 2)
pfn = archs.PFN(input_dim=input_dim,
Phi_sizes=[10],
F_sizes=[10],
mask_val=mask_val)
pfn.fit(X_train, y_train, epochs=1)
X_test = np.random.rand(n, m2, input_dim)
X_test_mask = np.concatenate((X_test, mask_val * np.ones(
(n, 5, input_dim))),
axis=1)
assert epsilon_diff(pfn.predict(X_test), pfn.predict(X_test_mask), 10**-15)
kf = K.function(inputs=pfn.inputs, outputs=pfn.latent)
pure_mask = kf([0 * X_test + mask_val])[0]
assert epsilon_diff(pure_mask, 0, 10**-15)
def test_measure_ee(event, beta, theta_eps, kappa, normed):
if kappa == 'pf' and normed:
pytest.skip()
Es = event[:,0]
emeas = ef.Measure('ee', beta, kappa, normed, 'epxpypz', True)
ezs, ethetas = emeas.evaluate(event)
# compute naively
if kappa == 'pf':
zs = np.ones(len(Es))
phats = event
else:
if normed:
zs = Es**kappa/np.sum(Es**kappa)
else:
zs = Es**kappa
phats = event/Es[:,np.newaxis]
thetas = np.asarray([[2*abs(phti[0]*phtj[0]-np.dot(phti[1:],phtj[1:])) for phti in phats] for phtj in phats])**(beta/2)
assert epsilon_diff(ezs, zs, 10**-13)
assert epsilon_diff(ethetas, thetas, 10**-theta_eps)
def test_linear_relations(measure):
graphs ={# d=0
'dot': [],
# d=1
'line': [(0,1)],
# d=2
'dumbbell': [(0,1), (0,1)],
'wedge': [(0,1),(1,2)],
'linesqd' : [(0,1),(2,3)],
# d = 3
'tribell' : [(0,1),(0,1),(0,1)],
'triangle' : [(0,1),(1,2),(2,0)],
'asymwedge' : [(0,1),(0,1),(1,2)],
'birdfoot' : [(0,1),(0,2),(0,3)],
'chain' : [(0,1),(1,2),(2,3)],
'linedumbbell' : [(0,1),(2,3),(2,3)],
'linewedge' : [(0,1),(2,3),(3,4)],
'linecbd' : [(0,1),(2,3),(4,5)],
# d = 4
'quadbell' : [(0,1),(0,1),(0,1),(0,1)],
'doublewedge' : [(0,1),(0,1),(1,2),(1,2)],
'icecreamcone' : [(0,1),(0,1),(1,2),(2,0)],
'asymwedge2' : [(0,1),(0,1),(0,1),(1,2)],
'square' : [(0,1),(1,2),(2,3),(3,0)],
'flyswatter' : [(0,1),(1,2),(2,3),(3,1)],
'chain2mid' : [(0,1),(1,2),(1,2),(2,3)],
'chain2end' : [(0,1),(1,2),(2,3),(2,3)],
'asymbirdfoot' : [(0,1),(0,1),(1,2),(1,3)],
'bigbirdfoot' : [(0,1),(0,2),(0,3),(0,4)],
'dog' : [(0,1),(1,2),(2,3),(2,4)],
'bigchain' : [(0,1),(1,2),(2,3),(3,4)],
'dumbbellwedge' : [(0,1),(0,1),(2,3),(3,4)],
'triangleline' : [(0,1),(1,2),(2,0),(3,4)],
'dumbbellsqd' : [(0,1),(0,1),(2,3),(2,3)],
# d = 5
'pentagon' : [(0,1),(1,2),(2,3),(3,4),(4,0)],
'triangledumbbell': [(0,1),(0,1),(2,3),(3,4),(4,2)]
}
# pick a random event with 2 particles
event = ef.gen_random_events(1, 2, dim=4)
# compute the value of all of the EFPs on this event
d = {name: ef.EFP(graph, measure=measure, coords='epxpypz')(event) for name,graph in graphs.items()}
eps = 10**-8
# check that the identities in the EFM paper are valid (i.e. = 0)
assert epsilon_diff(2 * d['wedge'] - d['dumbbell'], 0, eps)
assert epsilon_diff(2 * d['triangle'], 0, eps)
assert epsilon_diff(d['tribell'] - 2 * d['asymwedge'], 0, eps)
assert epsilon_diff(2 * d['chain'] - d['linedumbbell'] - d['triangle'], 0, eps)
assert epsilon_diff(d['birdfoot'] + d['chain'] - d['asymwedge'], 0, eps)
# Four Dimensions
# pick a random event in 4 dimensions
event = ef.gen_random_events(1, 25, dim=4)
# compute the value of all of the EFPs on this event
d = {name: ef.EFP(graph, measure=measure, coords='epxpypz')(event) for name,graph in graphs.items()}
# check that the identity in the paper is valid (i.e. = 0)
assert epsilon_percent(6*d['pentagon'], 5*d['triangledumbbell'], 10**-11)
# count the number of leafless multigraphs (all or just connected) with degree d
ds = np.arange(11)
counts_all, counts_con = [], []
# for each degree, get the graphs with edges<=d and check whether they are leafless
for d in ds:
counts_all.append(np.sum([leafless(graph) for graph in ef.EFPSet(('d<=',d)).graphs()]))
counts_con.append(np.sum([leafless(graph) for graph in ef.EFPSet(('d<=',d), ('p==',1)).graphs()]))
# note: computed counts are cumulative, must take the difference to get individual d
counts_all = np.asarray(counts_all[1:]) - np.asarray(counts_all[:-1])
counts_con = np.asarray(counts_con[1:]) - np.asarray(counts_con[:-1])
# ensure agreement with the table in the paper
assert epsilon_diff(counts_all, [0,1,2,5,11,34,87,279,897,3129], eps)
assert epsilon_diff(counts_con, [0,1,2,4,9,26,68,217,718,2553], eps)
