def test_beta():
N = 30
dv = 3
dc = 6
num_codewords = 10
H = get_H(N, dv, dc)
codewords = get_codewords(H, num_codewords)
p = 0.25
max_iter = 10
trials = 100
print 'GOT ALL CODEWORDS'
step = 0.1
b = np.arange(0, 0.5, step)
results = set()
for beta in b:
success_rate = [0] * num_codewords
print beta,
for i, word in enumerate(codewords):
for _ in xrange(trials):
codeword = word
codeword = convert_to_posneg(codeword)
codeword = simulateBEC(p, codeword)
f = FactorGraph(H)
codeword = f.decode_BEC_memoryless(codeword, beta, max_iter)
codeword = convert_to_zeroone(codeword)
if tuple(codeword) == word:
success_rate[i] += 1 / float(trials)
stat = np.average(success_rate)
print stat
results.add(tuple([beta, stat]))
print results
for point in results:
plt.plot(point[0], point[1], 'ro')
plt.show()
def __init__(self, verbose=False, progress=False, color=False, setformula=True, stats=False, scheduler=4, skip=True, size=3, stdout=sys.stdout, utf8=True):
self.verbose = verbose
self.progress = progress
self.color = color
self.setformula = setformula
self.stats = stats
self.scheduler = scheduler
self.skip = skip
self.stdout = stdout
self.utf8 = utf8
self.p = size
self.q = self.p*self.p
if not self.setformula and self.scheduler == 0:
if self.stats:
self.op = NumpyOperationsStats(self.q)
else:
self.op = NumpyOperations(self.q)
else:
if self.stats:
self.op = SudokuOperationsStats(self.q)
else:
self.op = SudokuOperations(self.q)
self.counter = 0
self.graph = FactorGraph(self.q*self.q, 3*self.q, self.edge, self.op, self.print_sudoku if self.verbose and self.progress else lambda *args: None)
def test_N():
use_sql = False
if (use_sql):
conn = sqlite3.connect('blocklength.db')
c = conn.cursor()
c.execute('''CREATE TABLE points
(N integer, alpha real, beta real, perror real, sd real)''')
dv = 3
dc = 6
alpha = 0.25
beta = 0.1
START = 450
END = 450
STEP = START
REPEAT = 10
TRIALS = 15
for N in xrange(START, END + STEP, STEP):
if (use_sql):
conn.commit()
print '***', N, '***'
H = get_H(N, dv, dc)
# print 'H DONE'
word = [0] * N
max_iter = N / 4
failure_rate = [0] * TRIALS
noiseless_failure_rate = [0] * TRIALS
for i in xrange(TRIALS):
for _ in xrange(REPEAT):
# print i
codeword = word
codeword = convert_to_posneg(codeword)
codeword = simulateBEC(alpha, codeword)
f = FactorGraph(H)
codeword = f.decode_BEC_memory(codeword, beta, max_iter)
codeword = convert_to_zeroone(codeword)
if codeword != word:
failure_rate[i] += 1.0 / REPEAT
# print 'SD', np.std(failure_rate)
if N == START:
plt.errorbar(N,
np.average(failure_rate),
np.std(failure_rate),
linestyle='None',
marker='o',
color='red',
label='beta = 0.1')
else:
plt.errorbar(N,
np.average(failure_rate),
np.std(failure_rate),
linestyle='None',
marker='o',
color='red')
if (use_sql):
c.execute('INSERT INTO points VALUES (?,?,?,?,?)',
(N, alpha, beta, np.average(failure_rate),
np.std(failure_rate)))
'''
for i in xrange(TRIALS):
for _ in xrange(REPEAT):
# print i
codeword = word
codeword = convert_to_posneg(codeword)
codeword = simulateBEC(alpha, codeword)
f = FactorGraph(H)
codeword = f.decode_BEC_memoryless(codeword, 0, max_iter)
codeword = convert_to_zeroone(codeword)
if codeword != word:
noiseless_failure_rate[i] += 1.0 / REPEAT
if N == START:
plt.errorbar(N, np.average(noiseless_failure_rate), np.std(noiseless_failure_rate), linestyle='None', marker='o', color='blue', label='beta = 0')
else:
plt.errorbar(N, np.average(noiseless_failure_rate), np.std(noiseless_failure_rate), linestyle='None', marker='o', color='blue')
if(use_sql):
c.execute('INSERT INTO points VALUES (?,?,?,?,?)', (N, alpha, 0, np.average(noiseless_failure_rate), np.std(noiseless_failure_rate)))
#plt.show()
'''
#for point in noisy_results:
# plt.plot(point[0], point[1], 'ro')
#for point in noiseless_results:
# plt.plot(point[0], point[1], 'bo')
plt.axis((0, N + STEP, -0.05, 0.5))
plt.xlabel('Block Length')
plt.ylabel('Probability of Error')
plt.legend(loc='upper right')
plt.suptitle('Block Length vs. Probability of Error for alpha = 0.25')
plt.xticks(np.arange(0, END + STEP, STEP))
plt.yticks(np.arange(0, 0.5 + 0.05, 0.05))
if (use_sql):
conn.commit()
print 'DONE'
plt.show()
def file_reader(file_name, exact_method=True):
"""Parse the graph structure and the look up table from the uai and evid file"""
dir = os.path.dirname(os.path.realpath(__file__))
### read the uai file
with open(dir + '/uai/' + file_name) as f:
line = f.readline()
graph_type = line.strip('\n')
#print (graph_type)
node_number = int(f.readline())
#print (node_number)
line = f.readline().strip(' \n').strip(' ')
try:
line2 = line.split(' ')
variable_cardinality = list(map(int, line2))
except Exception as e:
line2 = line.split(" ")
variable_cardinality = list(map(int, line2))
#print (variable_cardinality)
clique_number = int(f.readline())
#print (clique_number)
graph = Graph(graph_type, node_number, variable_cardinality,
clique_number)
for i in range(clique_number): # start from 0
line = f.readline().strip('\n').strip(' ')
#print(line)
try:
line = np.array(list(map(int, line.split('\t'))))
except Exception as e:
line = np.array(list(map(int, line.split(' '))))
# print(line)
size = line[0]
# print(size)
nodes = list(line[1:])
# print(nodes)
clique = Clique(size, nodes)
graph.add_clique(i, clique)
for i in range(clique_number):
line = f.readline().strip('\n')
if line == '':
line = f.readline().strip('\n')
table_size = int(line)
# print(table_size)
read = 0
psi = []
while read < table_size:
line = f.readline().strip('\n').strip(' ').split(' ')
read = read + len(line)
psi.append(list(map(float, line)))
graph.add_clique_table(i, psi)
### read the evidence file
"""
with open(dir + '/uai/' + file_name +'.evid') as evidence:
line = evidence.readline().strip('\n').strip(' ')
try:
line = np.array(list(map(int,line.split('\t'))))
except Exception as e:
line = np.array(list(map(int,line.split(' '))))
evid_size = line[0]
if evid_size != 0:
evidence = {}
for i in range(0, evid_size):
evidence[line[2*i+1]] = line[2*i+2]
graph.set_evidence(evidence)
"""
# test for the parse
#print(graph.adjacent[1])
#for v in graph.node_sharing_cliques[1]:
#print(v.table)
#print(graph.evidence)
# graph.triangulation()
# graph.maxcliques()
#
#
#
if exact_method:
start = time.clock()
#print('test result')
#graph.test()
JT = graph.generate_JT()
JT.traverse()
elapsed = (time.clock() - start)
print("Time used:", elapsed, 's')
else:
#######################
#Here to run the LBP
######################
start = time.clock()
graph.pairwise()
factorgraph = FactorGraph(graph)
factorgraph.LBP(normalize=True)
factorgraph.calculate_z()
print("Time used", time.clock() - start, 's')
