def test_mergeNode_ArrayTensor():
for i in range(5):
net = Network()
x = np.random.randn(2, 3, 3)
xt = ArrayTensor(x)
n1 = Node(xt)
xt = ArrayTensor(x)
n2 = Node(xt)
net.addNode(n1)
Link(n1.buckets[0], n2.buckets[0])
net.addNode(n2)
net.mergeNodes(n1, n2)
assert len(net.nodes) == 1
assert len(net.buckets) == 4
assert len(net.internalBuckets) == 0
assert len(net.externalBuckets) == 4
assert len(net.optimizedLinks) == 0
arr, bdict = net.array
assert arr.shape == (3, 3, 3, 3)
for b in net.buckets:
assert b.id in bdict
for b1 in net.buckets:
for b2 in net.buckets:
if b1.id < b2.id:
assert bdict[b1.id] < bdict[b2.id]
assert np.sum((arr - np.einsum('ijk,ilm->jklm', x, x))**2) < epsilon
def test_mergeLinks_TreeTensor_Compress():
for i in range(5):
net = Network()
x = np.random.randn(2, 2, 2, 2, 3, 3)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
n1 = Node(xt)
x = np.random.randn(2, 2, 2, 2, 3, 3)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
n2 = Node(xt)
net.addNode(n1)
Link(n1.buckets[0], n2.buckets[0])
Link(n1.buckets[1], n2.buckets[1])
net.addNode(n2)
arr1, bdict1 = net.array
net.mergeLinks(n1, compress=True, accuracy=epsilon)
arr2, bdict2 = net.array
assert np.sum((arr1 - arr2)**2) < epsilon
assert np.sum((arr1 - arr2)**2) < epsilon
def test_init():
net = Network()
assert len(net.nodes) == 0
assert len(net.buckets) == 0
assert len(net.internalBuckets) == 0
assert len(net.externalBuckets) == 0
assert len(net.optimizedLinks) == 0
x = np.random.randn(2, 3, 3)
xt = ArrayTensor(x)
n1 = Node(xt)
net.addNode(n1)
assert len(net.nodes) == 1
assert len(net.buckets) == 3
assert len(net.internalBuckets) == 0
assert len(net.externalBuckets) == 3
assert len(net.optimizedLinks) == 0
x = np.random.randn(2, 3, 3)
xt = ArrayTensor(x)
n2 = Node(xt)
Link(n1.buckets[0], n2.buckets[0])
net.addNode(n2)
assert len(net.nodes) == 2
assert len(net.buckets) == 6
assert len(net.internalBuckets) == 2
assert len(net.externalBuckets) == 4
assert len(net.optimizedLinks) == 0
net.removeNode(n1)
assert len(net.nodes) == 1
assert len(net.buckets) == 3
assert len(net.internalBuckets) == 0
assert len(net.externalBuckets) == 3
assert len(net.optimizedLinks) == 0
def test_mergeLinks_ArrayTensor():
for i in range(5):
net = Network()
x = np.random.randn(2, 2, 3, 3)
xt = ArrayTensor(x)
n1 = Node(xt)
xt = ArrayTensor(x)
n2 = Node(xt)
net.addNode(n1)
Link(n1.buckets[0], n2.buckets[0])
Link(n1.buckets[1], n2.buckets[1])
net.addNode(n2)
arr1, bdict1 = net.array
net.mergeLinks(n1)
arr2, bdict2 = net.array
assert np.sum((arr1 - arr2)**2) < epsilon
assert np.sum((arr1 - arr2)**2) < epsilon
def test_mergeNode_TreeTensor():
for i in range(5):
net = Network()
x = np.random.randn(2, 2, 2, 2, 2)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(x))
n1 = Node(xt)
y = np.random.randn(2, 2, 2, 2, 2)
xt = TreeTensor(accuracy=epsilon)
xt.addTensor(ArrayTensor(y))
n2 = Node(xt)
net.addNode(n1)
Link(n1.buckets[0], n2.buckets[0])
net.addNode(n2)
net.mergeNodes(n1, n2)
assert len(net.nodes) == 1
assert len(net.buckets) == 8
assert len(net.internalBuckets) == 0
assert len(net.externalBuckets) == 8
assert len(net.optimizedLinks) == 0
arr, bdict = net.array
assert arr.shape == (2, 2, 2, 2, 2, 2, 2, 2)
for b in net.buckets:
assert b.id in bdict
for b1 in net.buckets:
for b2 in net.buckets:
if b1.id < b2.id:
assert bdict[b1.id] < bdict[b2.id]
assert np.sum(
(arr - np.einsum('ijklm,iqwer->jklmqwer', x, y))**2) < epsilon
def PA2D(nX, nY, h, J, q, accuracy):
network = Network()
# Place to store the tensors
lattice = [[] for i in range(nX)]
bondL = [[] for i in range(nX)]
# Each lattice site has seven indices of width five, and returns zero if
# they are unequal and one otherwise.
for i in range(nX):
for j in range(nY):
lattice[i].append(Node(IdentityTensor(2, 5, accuracy=accuracy)))
arr = np.zeros((2, 2))
# 2-point
arr[0][0] = np.exp(-J)
arr[1][1] = np.exp(-J)
arr[0][1] = np.exp(J)
arr[1][0] = np.exp(J)
# 1-point
arr[0] *= np.exp(h / 4)
arr[1] *= np.exp(-h / 4)
# Expand
arr = np.einsum('ij,ik,il,ia->ijkla', arr, arr, arr, arr)
# 3-point
arr[1, 1, :, 1, :] = 0
arr[1, 1, :, :, 1] = 0
arr[1, :, 1, 1, :] = 0
arr[1, :, 1, :, 1] = 0
# 4-point
arr[1, 1, 1, 1, :] = np.exp(q)
arr[1, 1, 1, :, 1] = np.exp(q)
arr[1, 1, :, 1, 1] = np.exp(q)
arr[1, :, 1, 1, 1] = np.exp(q)
# 5-point
for j in range(2):
for k in range(2):
for l in range(2):
for m in range(2):
if j + k + l + m >= 4:
arr[1, j, k, l, m] = 0
# Make L-bonds
for i in range(nX):
for j in range(nY):
bondL[i].append(Node(ArrayTensor(arr)))
# Attach links
for i in range(nX):
for j in range(nY):
Link(lattice[i][j].buckets[0], bondL[i][j].buckets[0])
Link(lattice[i][j].buckets[1], bondL[(i + 1) % nX][j].buckets[1])
Link(lattice[i][j].buckets[2], bondL[i - 1][j].buckets[2])
Link(lattice[i][j].buckets[3], bondL[i][(j + 1) % nY].buckets[3])
Link(lattice[i][j].buckets[4], bondL[i][j - 1].buckets[4])
# Add to Network
for i in range(nX):
for j in range(nY):
network.addNode(lattice[i][j])
network.addNode(bondL[i][j])
return network
def BayesTest2(observations, discreteG, discreteQ, discreteW, discreteH,
accuracy):
'''
observations is a list of (k,M) pairs
where k is the number of heads and M-k is the
number of tails in a repeated Bernoulli coin toss.
This model represents the likelihood
L = M! p^k (1-p)^(M-k)/(k!(M-k)!)
summed over all coins that were observed.
Here we model
p_i = min(g*h_i + q^w, 1)
where each of g, q, w and h_i lie in [0,1]
and have uniform priors. g, w and q are global parameters.
discrete(G,W,Q) specify the g, w and q values to sample.
discreteH is the same for h_i.
'''
network = Network()
# Local tensors
hs = []
for i, obs in enumerate(observations):
arr = np.zeros(
(len(discreteG), len(discreteQ), len(discreteW), len(discreteH)))
for j, gg in enumerate(discreteG):
for k, qq in enumerate(discreteQ):
for e, ww in enumerate(discreteW):
for l, h in enumerate(discreteH):
p = min(gg * h + qq**ww, 1)
arr[j, k, e,
l] = factorial(obs[1]) * p**obs[0] * (1 - p)**(
obs[1] - obs[0]) / (factorial(obs[0]) *
factorial(obs[1] - obs[0]))
# Marginalizes over all of the individual distributions
arr = np.sum(arr, axis=-1)
h = Node(ArrayTensor(arr))
hs.append(h)
extG = [h.buckets[0] for h in hs]
extW = [h.buckets[1] for h in hs]
extQ = [h.buckets[2] for h in hs]
nodes = []
dimension = len(discreteG)
while len(extG) > 1:
iden = np.zeros((dimension, dimension, dimension))
for i in range(dimension):
iden[i, i, i] = 1.0
n = Node(IdentityTensor(dimension, 3, accuracy=accuracy))
nodes.append(n)
Link(n.buckets[0], extG[0])
Link(n.buckets[1], extG[1])
extG.append(n.buckets[2])
extG = extG[2:]
dimension = len(discreteW)
while len(extW) > 1:
iden = np.zeros((dimension, dimension, dimension))
for i in range(dimension):
iden[i, i, i] = 1.0
n = Node(IdentityTensor(dimension, 3, accuracy=accuracy))
nodes.append(n)
Link(n.buckets[0], extW[0])
Link(n.buckets[1], extW[1])
extW.append(n.buckets[2])
extW = extW[2:]
dimension = len(discreteQ)
while len(extQ) > 1:
iden = np.zeros((dimension, dimension, dimension))
for i in range(dimension):
iden[i, i, i] = 1.0
n = Node(IdentityTensor(dimension, 3, accuracy=accuracy))
nodes.append(n)
Link(n.buckets[0], extQ[0])
Link(n.buckets[1], extQ[1])
extQ.append(n.buckets[2])
extQ = extQ[2:]
for h in hs:
network.addNode(h)
for n in nodes:
network.addNode(n)
return network
def BayesTest1(observations, discreteG, discreteQ, discreteW, discreteH,
accuracy):
'''
observations is a list of (k,M) pairs
where k is the number of heads and M-k is the
number of tails in a repeated Bernoulli coin toss.
This model represents the likelihood
L = M! p^k (1-p)^(M-k)/(k!(M-k)!)
summed over all coins that were observed.
Here we model
p_i = min(g*h_i + q^w, 1)
where each of g, q, w and h_i lie in [0,1]
and have uniform priors. g, w and q are global parameters.
discrete(G,W,Q) specify the g, w and q values to sample.
discreteH is the same for h_i.
'''
network = Network()
# Global tensors
n = len(observations)
g = Node(IdentityTensor(len(discreteG), n + 1, accuracy=accuracy))
q = Node(IdentityTensor(len(discreteQ), n + 1, accuracy=accuracy))
w = Node(IdentityTensor(len(discreteW), n + 1, accuracy=accuracy))
# Local tensors
hs = []
for i, obs in enumerate(observations):
arr = np.zeros(
(len(discreteG), len(discreteQ), len(discreteW), len(discreteH)))
for j, gg in enumerate(discreteG):
for k, qq in enumerate(discreteQ):
for e, ww in enumerate(discreteW):
for l, h in enumerate(discreteH):
p = min(gg * h + qq**ww, 1)
arr[j, k, e,
l] = factorial(obs[1]) * p**obs[0] * (1 - p)**(
obs[1] - obs[0]) / (factorial(obs[0]) *
factorial(obs[1] - obs[0]))
# Marginalizes over all of the individual distributions
arr = np.sum(arr, axis=-1)
h = Node(ArrayTensor(arr))
hs.append(h)
Link(h.buckets[0], g.buckets[i])
Link(h.buckets[1], q.buckets[i])
Link(h.buckets[2], w.buckets[i])
# Assemble the network
network.addNode(g)
network.addNode(q)
network.addNode(w)
for h in hs:
network.addNode(h)
return network
def PA3D(nX, nY, nZ, h, J, q, accuracy):
network = Network()
# Place to store the tensors
lattice = [[[] for j in range(nY)] for i in range(nX)]
bondL = [[[] for j in range(nY)] for i in range(nX)]
# Each lattice site has seven indices of width five, and returns zero if
# they are unequal and one otherwise.
for i in range(nX):
for j in range(nY):
for k in range(nZ):
lattice[i][j].append(
Node(IdentityTensor(2, 7, accuracy=accuracy)))
arr = np.zeros((2, 2))
# 2-point
arr[0][0] = np.exp(-J)
arr[1][1] = np.exp(-J)
arr[0][1] = np.exp(J)
arr[1][0] = np.exp(J)
# 1-point
arr[0] *= np.exp(h / 6)
arr[1] *= np.exp(-h / 6)
# Expand
arr = np.einsum('ij,ik,il,ia,ib,ic->ijklabc', arr, arr, arr, arr, arr, arr)
# 3-point
arr[1, 1, :, 1, :, :, :] = 0
arr[1, 1, :, :, 1, :, :] = 0
arr[1, 1, :, :, :, 1, :] = 0
arr[1, 1, :, :, :, :, 1] = 0
arr[1, :, 1, 1, :, :, :] = 0
arr[1, :, 1, :, 1, :, :] = 0
arr[1, :, 1, :, :, 1, :] = 0
arr[1, :, 1, :, :, :, 1] = 0
arr[1, 1, :, 1, :, :, :] = 0
arr[1, :, 1, 1, :, :, :] = 0
arr[1, :, :, 1, :, 1, :] = 0
arr[1, :, :, 1, :, :, 1] = 0
arr[1, 1, :, :, 1, :, :] = 0
arr[1, :, 1, :, 1, :, :] = 0
arr[1, :, :, :, 1, 1, :] = 0
arr[1, :, :, :, 1, :, 1] = 0
arr[1, 1, :, :, :, 1, :] = 0
arr[1, :, 1, :, :, 1, :] = 0
arr[1, :, :, 1, :, 1, :] = 0
arr[1, :, :, :, 1, 1, :] = 0
arr[1, 1, :, :, :, :, 1] = 0
arr[1, :, 1, :, :, :, 1] = 0
arr[1, :, :, 1, :, :, 1] = 0
arr[1, :, :, :, 1, :, 1] = 0
# 4-point
arr[1, 1, 1, 1, :, :, :] = np.exp(q)
arr[1, 1, 1, :, 1, :, :] = np.exp(q)
arr[1, 1, 1, :, :, 1, :] = np.exp(q)
arr[1, 1, 1, :, :, :, 1] = np.exp(q)
arr[1, 1, :, 1, 1, :, :] = np.exp(q)
arr[1, :, 1, 1, 1, :, :] = np.exp(q)
arr[1, :, :, 1, 1, 1, :] = np.exp(q)
arr[1, :, :, 1, 1, :, 1] = np.exp(q)
arr[1, 1, :, :, :, 1, 1] = np.exp(q)
arr[1, :, 1, :, :, 1, 1] = np.exp(q)
arr[1, :, :, 1, :, 1, 1] = np.exp(q)
arr[1, :, :, :, 1, 1, 1] = np.exp(q)
# 5-point
for j in range(2):
for k in range(2):
for l in range(2):
for m in range(2):
for n in range(2):
for p in range(2):
if j + k + l + m + n + p >= 4:
arr[1, j, k, l, m, n, p] = 0
t = ArrayTensor(arr)
tt = TreeTensor(accuracy)
tt.addTensor(t)
# Make L-bonds
for i in range(nX):
for j in range(nY):
for k in range(nZ):
bondL[i][j].append(Node(deepcopy(tt)))
# Attach links
for i in range(nX):
for j in range(nY):
for k in range(nZ):
Link(lattice[i][j][k].buckets[0], bondL[i][j][k].buckets[0])
Link(lattice[i][j][k].buckets[1],
bondL[(i + 1) % nX][j][k].buckets[1])
Link(lattice[i][j][k].buckets[2],
bondL[i - 1][j][k].buckets[2])
Link(lattice[i][j][k].buckets[3],
bondL[i][(j + 1) % nY][k].buckets[3])
Link(lattice[i][j][k].buckets[4],
bondL[i][j - 1][k].buckets[4])
Link(lattice[i][j][k].buckets[5],
bondL[i][j][(k + 1) % nZ].buckets[5])
Link(lattice[i][j][k].buckets[6],
bondL[i][j][k - 1].buckets[6])
# Add to Network
for i in range(nX):
for j in range(nY):
for k in range(nZ):
network.addNode(lattice[i][j][k])
network.addNode(bondL[i][j][k])
return network