def tst_prod_rules_level1_individual(in_path):
# files = glob("ProdRules/moreno_lesmis_lesmis.*_iprules.tsv")
mdf = pd.DataFrame()
for f in sorted(files, reverse=True):
df = pd.read_csv(f, header=None, sep="\t")
mdf = pd.concat([mdf, df])
# print f, mdf.shape
# print mdf.head()
g = pcfg.Grammar('S')
from td_isom_jaccard_sim import listify_rhs
for (id, lhs, rhs, prob) in df.values:
rhs = listify_rhs(rhs)
# print (id), (lhs), (rhs), (prob)
g.add_rule(pcfg.Rule(id, lhs, rhs, float(prob)))
num_nodes = 16 # G.number_of_nodes()
print "Starting max size", 'n=', num_nodes
g.set_max_size(num_nodes)
print "Done with max size"
Hstars = []
print '-' * 40
try:
rule_list = g.sample(num_nodes)
except Exception, e:
print str(e)
continue
hstar = phrg.grow(rule_list, g)[0]
Hstars.append(hstar)
print '+' * 40
def grow_exact_size_hrg_graphs_from_prod_rules(prod_rules, gname, n, runs=1):
"""
Args:
rules: production rules (model)
gname: graph name
n: target graph order (number of nodes)
runs: how many graphs to generate
Returns: list of synthetic graphs
"""
DBG = True
if n <= 0: sys.exit(1)
g = pcfg.Grammar('S')
for (id, lhs, rhs, prob) in prod_rules:
g.add_rule(pcfg.Rule(id, lhs, rhs, prob))
print
print "Added rules HRG (pr", len(prod_rules), ", n,", n, ")"
num_nodes = n
if DBG: print "Starting max size ..."
t_start = time.time()
g.set_max_size(num_nodes)
print "Done with max size, took %s seconds" % (time.time() - t_start)
hstars_lst = []
print " ",
i = 0
max_tries = 10000
tries = 0
failed = False
while i != runs:
tries += 1
if tries > max_tries:
failed = True
break
print '>',
rule_list = g.sample(num_nodes)
hstar = phrg.grow(rule_list, g)[0]
if n * 0.99 <= hstar.order() <= n * 1.01:
hstars_lst.append(hstar)
i += 1
if len(hstars_lst) != runs or failed:
print('HRG failed')
return None
return hstars_lst
def Hstar_Graphs_Control(G, graph_name, axs=None):
# Derive the prod rules in a naive way, where
prod_rules = phrg.probabilistic_hrg_learning(G)
pp.pprint(prod_rules)
g = pcfg.Grammar('S')
for (id, lhs, rhs, prob) in prod_rules:
g.add_rule(pcfg.Rule(id, lhs, rhs, prob))
num_nodes = G.number_of_nodes()
print "Starting max size", 'n=', num_nodes
g.set_max_size(num_nodes)
print "Done with max size"
Hstars = []
num_samples = 20
print '*' * 40
for i in range(0, num_samples):
rule_list = g.sample(num_nodes)
hstar = phrg.grow(rule_list, g)[0]
Hstars.append(hstar)
# if 0:
# g = nx.from_pandas_dataframe(df, 'src', 'trg', edge_attr=['ts'])
# draw_degree_whole_graph(g,axs)
# draw_degree(Hstars, axs=axs, col='r')
# #axs.set_title('Rules derived by ignoring time')
# axs.set_ylabel('Frequency')
# axs.set_xlabel('degree')
if 0:
# metricx = [ 'degree','hops', 'clust', 'assort', 'kcore','eigen','gcd']
metricx = ['clust']
# g = nx.from_pandas_dataframe(df, 'src', 'trg',edge_attr=['ts'])
# graph_name = os.path.basename(f_path).rstrip('.tel')
if DBG: print ">", graph_name
metrics.network_properties([G],
metricx,
Hstars,
name=graph_name,
out_tsv=True)
def grow_hrg_graphs_with_infinity(
prod_rules,
gname,
n,
runs=1,
rnbr=1,
):
"""
Args:
rules: production rules (model)
gname: graph name
n: target graph order (number of nodes)
runs: how many graphs to generate
Returns: list of synthetic graphs
"""
DBG = True
if n <= 0: sys.exit(1)
g = pcfg.Grammar('S')
for (id, lhs, rhs, prob) in prod_rules:
g.add_rule(pcfg.Rule(id, lhs, rhs, prob))
print
print "Added rules HRG (pr", len(prod_rules), ", n,", n, ")"
num_nodes = n
if DBG: print "Starting max size ..."
t_start = time.time()
g.set_max_size(num_nodes)
print "Done with max size, took %s seconds" % (time.time() - t_start)
hstars_lst = []
print " ",
for i in range(0, runs):
rule_list = g.sample(num_nodes)
hstar = phrg.grow(rule_list, g)[0]
hstars_lst.append(hstar)
return hstars_lst
def main_inf_mirr(gFname, gName, rnbr=1):
retVal = None
G = xt.load_edgelist(gFname)
# rnbr = 1
# for j in range(1, rnbr + 1):
# prs = get_hrg_production_rules_given(G)
Hstars = [
] # synthetic (stochastically generate) graphs using the graph grammars
ProdRulesKth = []
# Note that therem might not be convergence, b/c the graph may degenerate early
for j in range(0, 10): # nbr of times to do Inf. Mirr. tst
for k in range(0, 1): # nbr of times to feedback the resulting graph
# print ("\tGraph #:",k+1)
prdrls = {}
prod_rules = phrg.probabilistic_hrg_deriving_prod_rules(G)
# print len(prod_rules)
# initialize the Grammar g
g = pcfg.Grammar('S')
for (id, lhs, rhs, prob) in prod_rules:
g.add_rule(pcfg.Rule(id, lhs, rhs, prob))
num_nodes = G.number_of_nodes()
g.set_max_size(num_nodes)
print "Done initializing the grammar data-structure"
# Generate a synthetic graph using HRGs
try:
rule_list = g.sample(num_nodes)
except Exception, e:
print str(e)
rule_list = g.sample(num_nodes)
break
hstar = phrg.grow(rule_list, g)[0]
G = hstar # feed back the newly created graph
# store the last synth graph & restart
Hstars.append(hstar) #
import core.PHRG as phrg
import core.probabilistic_cfg as pcfg
G = graph
Hstars = [
] # synthetic (stochastically generate) graphs using the graph grammars
ProdRulesKth = []
# Note that therem might not be convergence, b/c the graph may degenerate early
for j in range(0, 10): # nbr of times to do Inf. Mirr. tst
for k in range(1,
rnbr + 1): # nbr of times to feedback the resulting graph
prdrls = {}
prod_rules = phrg.probabilistic_hrg_deriving_prod_rules(G)
# print len(prod_rules)
# initialize the Grammar g
g = pcfg.Grammar('S')
for (id, lhs, rhs, prob) in prod_rules:
g.add_rule(pcfg.Rule(id, lhs, rhs, prob))
num_nodes = G.number_of_nodes()
g.set_max_size(num_nodes)
print "Done initializing the grammar data-structure"
# Generate a synthetic graph using HRGs
try:
rule_list = g.sample(num_nodes)
except Exception, e:
print str(e)
rule_list = g.sample(num_nodes)
break
def tst_prod_rules_isom_intrxn(fname, origfname):
"""
Test the isomorphic subset of rules
:param fname: isom intersection rules file
:param origfname: reference input network (dataset) edgelist file
:return:
"""
# Get the original file
fdf = Pandas_DataFrame_From_Edgelist([origfname])
origG = nx.from_pandas_dataframe(fdf[0], 'src', 'trg')
origG.name = graph_name(origfname)
print origG.name, "+" * 80
# Read the subset of prod rules
df = pd.read_csv(fname,
header=None,
sep="\t",
dtype={
0: str,
1: list,
2: list,
3: float
})
g = pcfg.Grammar('S')
if not willFire_check(df):
print "-" * 10, fname, "contains production rules that WillNotFire"
return None
else:
print "+" * 40
# Process dataframe
from td_isom_jaccard_sim import listify_rhs
for (id, lhs, rhs, prob) in df.values:
rhs = listify_rhs(rhs)
g.add_rule(pcfg.Rule(id, lhs, rhs, float(prob)))
print "\n", "." * 40 #print 'Added the rules to the datastructure'
num_nodes = origG.number_of_nodes()
# print "Starting max size", 'n=', num_nodes
g.set_max_size(num_nodes)
# print "Done with max size"
Hstars = []
ofname = "FakeGraphs/" + origG.name + "_isom_ntrxn.shl"
database = shelve.open(ofname)
num_samples = 20 #
print '~' * 40
for i in range(0, num_samples):
rule_list = g.sample(num_nodes)
hstar = phrg.grow(rule_list, g)[0]
Hstars.append(hstar)
print hstar.number_of_nodes(), hstar.number_of_edges()
print '-' * 40
database['hstars'] = Hstars
database.close()
