def test_backsolve(self):
expected = [
{ 0: 1.0000000000000036,
1: 3.9999999999999991,
2: -2.0000000000000004},
{ 0: -0.20000000000000007,
1: 3.9999999999999991,
2: -0.79999999999999905},
{0: 2.0, 1: 3.0, 2: -0.99999999999999989},
{0: 5.9999999999999964, 1: 7.5, 2: 1},
{0: 2.0, 1: 1},
{
0: -0.55555555555555547,
1: 0.72222222222222221,
2: -0.16666666666666674,
3: -1.2222222222222221}
]
for i in range(len(self.As)):
a = linalg.gaussianElim(self.As[i])
if not linalg.inconsistent(a):
free = linalg.determineFreeVariables(a)
assignments = {}
for var in free:
assignments[var] = 1
sol = linalg.backsolve(a, assignments)
if sol != expected[i]:
print "Failure expected on matrix", i
for row in self.As[i]:
print row
print "Inconsistent:", linalg.inconsistent(self.As[i])
self.assertTrue(sol == expected[i])
def instantiate( constraints, input, num_copies=1 ):
A = [row for row in constraints] # Make a copy.
if linalg.inconsistent(A):
raise Exception, "Unsatisfiable."
# http://en.wikipedia.org/wiki/Gaussian_elimination
A = linalg.gaussianElim(A)
free_vars = linalg.determineFreeVariables(A)
networks = [] # List to return
for i in range(num_copies):
assignments = {}
for var in free_vars:
assignments[var] = random()*20 - 10
solution = linalg.backsolve(A, assignments)
# If there are N elements of the solution, that amounts to
# sqrt(N) neurons with N connection weights between them all.
n = int(sqrt(len(solution)))
network = {
'n' : n + 2,
'consts' : [val for val in solution.values()],
'eqns' :
inputs.input_as_lambdas(input) +
[ lambda v, c : tanh(sum([v[j+2] + c[i*n + j]
for j in range(n)])) for i in range(n)]
}
networks.append(network)
return networks
def store_freevar_count(population, generation, trial_ID):
return
frees = [len(linalg.determineFreeVariables(o['constraints']))
for o in population]
counts = {}
for free in frees:
counts[free] = counts.get(free,0) + 1
for k in counts.keys():
if not k in range(len(o['constraints'])+1):
print k, len(o['constraints'])
raise "hell"
F = open("../dat/" + str(trial_ID) + ".fre", "a")
F.writelines([ ",".join([str(counts.get(i,0))
for i in range(len(o['constraints']))]) + '\n' ])
F.close()
def test_freevars(self):
expected = [[],[],[],[2],[1],[],[3]]
for i in range(len(self.As)):
a = linalg.gaussianElim(self.As[i])
free = linalg.determineFreeVariables(a)
self.assertTrue(free == expected[i])
