def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
self.graph.load_edgelist(StringIO(example_txt2))
self.graph.create_indices()
self.graph.create_index_degree()
self.graph.create_index_triangles()
self.graph.create_index_unseen_degree()
self.graph.index_parameter_from_parameter('triangles', 'unseen_triangles')
self.graph.add_parameter_cache('seen_degree')
self.graph.initialize_parameter('seen_degree', 0.0)
self.graph.index_parameter_cache('seen_degree')
self.graph.add_parameter_cache('seen_degree2')
self.graph.initialize_parameter('seen_degree2', 0.0)
self.graph.index_parameter_cache('seen_degree2')
self.graph.add_parameter_cache('seen_triangles')
self.graph.initialize_parameter('seen_triangles', 0.0)
self.graph.index_parameter_cache('seen_triangles')
self.graph.add_parameter_cache('seen_triangles2')
self.graph.initialize_parameter('seen_triangles2', 0.0)
self.graph.index_parameter_cache('seen_triangles2')
self.privacy_model = LinkPrivacyModel(self.graph, 1)
self.privacy_model.coverage_types = ['node','korolova','link','triangle']
def testTotalTriangles(self):
self.graph = BigGraph()
self.graph.create_indices()
self.graph.add_edge(1234000, 1234001)
self.graph.add_edge(1234001, 1234002)
self.graph.add_edge(1234002, 1234000)
self.graph.add_edge(1234000, 1234001)
self.graph.add_edge(1234001, 1234003)
self.graph.add_edge(1234003, 1234000)
self.graph.create_index_triangles()
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234000), 2)
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234001), 2)
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234002), 1)
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234003), 1)
self.assertEqual(self.graph.total_triangles(), 2)
self.assertEqual(self.graph.total_triangles_weight(1), 2)
self.assertEqual(self.graph.total_triangles_weight(2), 0)
self.assertEqual(self.graph.triangles_weight(1234000, 1), 2)
self.assertEqual(self.graph.triangles_weight(1234000, 2), 0)
self.assertEqual(self.graph.triangles_weight(6756443, 1), 0)
self.assertEqual(self.graph.triangles_weight(6756443, 2), 0)
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 2 * 20 #200000
self.graph.output_debug_nodes = 10000
self.graph.load_edgelist(StringIO(example_txt2))
self.graph.create_indices()
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
self.graph.create_indices()
self.graph.create_index_clustering()
self.graph.create_index_degree()
self.graph.create_index_knn()
self.graph.load_edgelist(StringIO(example_txt), num=False)
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.max_links_input = 50000
self.graph.input_debug_links = 1000 #200000
self.graph.output_debug_nodes = 10000
use_big_alphabet = False
self.graph.load_compressed_graph(cloudlight.tests.data_enc1,
use_big_alphabet, False)
self.graph.create_indices()
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
for i in range(5):
self.graph.add_edge(str(i), str(i + 1))
self.graph.add_edge(str(-i), str(-i - 1))
self.graph.create_indices()
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
self.graph.load_edgelist(StringIO(example_txt2))
self.graph.create_indices()
self.graph.create_index_degree()
self.graph.create_index_unseen_degree()
self.graph.create_index_triangles()
self.privacy_model = LinkPrivacyModel(self.graph, 1)
class Test(unittest.TestCase):
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 2 * 20 #200000
self.graph.output_debug_nodes = 10000
self.graph.load_edgelist(StringIO(example_txt2))
self.graph.create_indices()
def tearDown(self):
pass
def testName(self):
pass
def setUp3(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
edge = self.graph.add_edge
a,b,c,d,e,f,g,h,i = 'a','b','c','d','e','f','g','h','i'
edge(a,b)
edge(b,c)
edge(c,e)
edge(c,d)
edge(d,e)
edge(b,d)
edge(a,f)
edge(a,g)
edge(a,h)
edge(a,i)
edge(g,h)
edge(h,i)
self.graph.create_indices()
self.graph.create_index_degree()
self.graph.create_index_triangles()
self.graph.create_index_unseen_degree()
self.graph.index_parameter_from_parameter('triangles', 'unseen_triangles')
self.graph.add_parameter_cache('seen_degree')
self.graph.initialize_parameter('seen_degree', 0.0)
self.graph.index_parameter_cache('seen_degree')
self.graph.add_parameter_cache('seen_degree2')
self.graph.initialize_parameter('seen_degree2', 0.0)
self.graph.index_parameter_cache('seen_degree2')
self.graph.add_parameter_cache('seen_triangles')
self.graph.initialize_parameter('seen_triangles', 0.0)
self.graph.index_parameter_cache('seen_triangles')
self.graph.add_parameter_cache('seen_triangles2')
self.graph.initialize_parameter('seen_triangles2', 0.0)
self.graph.index_parameter_cache('seen_triangles2')
self.privacy_model = LinkPrivacyModel(self.graph, 1)
self.privacy_model.coverage_types = ['node','korolova','link','triangle']
self.privacy_model.initialize_histogram_degree(number_of_nodes=self.graph.number_of_nodes())
self.privacy_model.strategy = 'start_crawler_degree_hist'
def testStrategyTrianglesCoverage(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.max_links_input = 40000 #5000
self.graph.input_debug_links = 200000
self.graph.output_debug_nodes = 500
use_big_alphabet = False
self.graph.load_compressed_graph(cloudlight.tests.data_enc1, use_big_alphabet)
self.graph.create_indices()
self.graph.remove_degree_cache()
self.graph.create_index_degree()
self.graph.index_parameter_from_degree('unseen_degree')
lookahead = 1
coverage = 'korolova node'
self.strategies = PrivacyAttackStrategies(self.graph, lookahead, coverage, self.graph.debug)
self.coverages = [0.80] # [ float(f)/100 for f in range(2, 104, 2) ]
self.graph.create_index_triangles()
self.graph.index_parameter_from_parameter('triangles', 'unseen_triangles')
random.seed(7777)
self.graph.add_edge(1234000, 1234001)
self.graph.add_edge(1234001, 1234002)
self.graph.add_edge(1234002, 1234000)
self.graph.add_edge(1234000, 1234001)
self.graph.add_edge(1234001, 1234003)
self.graph.add_edge(1234003, 1234000)
coverage = 'triangle'
lookahead = 1
self.strategies = PrivacyAttackStrategies(self.graph, lookahead, coverage, self.graph.debug)
self.coverages = [0.80]
self.assertEqual( list(self.strategies.start_triangles(self.coverages))[0], 28)
def testActiveAttack(self):
self.graph = BigGraph()
g = self.graph
g.add_edge('3', '1')
g.add_edge('4', '1')
g.add_edge('5', '1')
g.add_edge('6', '5')
g.add_edge('2', '7')
g.add_edge('8', '2')
g.add_edge('9', '2')
self.assertEqual(list(self.graph.neighbors_iter('1')),
[u'3', u'4', u'5'])
self.graph.create_indices()
self.graph.create_index_degree()
self.graph.create_index_unseen_degree()
self.privacy_model = LinkPrivacyModel(self.graph, 2)
self.privacy_model.add_bribed_node('5')
self.assertEqual(self.privacy_model.korolova_node_coverage(),
0.55555555555555558)
self.privacy_model.add_false_link('1', '2')
self.assertEqual(set(self.graph.neighbors_iter('1')),
set([
u'3',
u'4',
u'5',
u'2',
]))
self.assertEqual(self.privacy_model.korolova_node_coverage(), 1.0)
def setUp(self):
debug = False
self.graph = BigGraph()
self.graph.debug = debug
self.graph.max_links_input = 100000
self.graph.input_debug_links = 200000
self.graph.output_debug_nodes = 10000
use_big_alphabet = False
self.graph.load_compressed_graph(cloudlight.tests.data_enc1, use_big_alphabet)
self.graph.create_indices()
self.graph.create_index_degree()
self.graph.create_index_unseen_degree()
self.graph.create_index_triangles()
lookahead = 1
coverage = 'korolova node'
self.strategies = PrivacyAttackStrategies(self.graph, lookahead, coverage, debug)
self.coverages = [0.1] # [ float(f)/100 for f in range(2, 104, 2) ]
def setUp(self):
pass
self.graph = BigGraph()
self.graph.debug = False
self.graph.max_links_input = 5000
self.graph.input_debug_links = 200000
self.graph.output_debug_nodes = 500
use_big_alphabet = False
self.graph.load_compressed_graph(cloudlight.tests.data_enc1, use_big_alphabet)
self.graph.create_indices()
self.graph.remove_degree_cache()
self.graph.create_index_degree()
self.graph.index_parameter_from_degree('unseen_degree')
lookahead = 1
coverage = 'korolova node'
self.strategies = PrivacyAttackStrategies(self.graph, lookahead, coverage, self.graph.debug)
self.coverages = [0.80] # [ float(f)/100 for f in range(2, 104, 2) ]
class Test(unittest.TestCase):
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
for i in range(5):
self.graph.add_edge(str(i), str(i + 1))
self.graph.add_edge(str(-i), str(-i - 1))
self.graph.create_indices()
def tearDown(self):
pass
class BigGraphTest3(unittest.TestCase):
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.max_links_input = 20000
self.graph.input_debug_links = 200000
self.graph.output_debug_nodes = 10000
use_big_alphabet = False
self.graph.load_compressed_graph(cloudlight.tests.data_enc1,
use_big_alphabet,
has_num=True)
self.graph.create_indices()
self.graph.create_index_kcores()
pass
def tearDown(self):
pass
def testNodes(self):
self.assertEqual(self.graph.number_of_nodes(), 18284)
def testEdges(self):
self.assertEqual(self.graph.number_of_edges(), 20000)
def testDegreesPartial(self):
self.assertEqual(list(self.graph.degrees_iter(['2', '3', '4'])),
[606, 595, 551])
def testClustering(self):
self.assertEqual(
list(
self.graph.clustering_indices_iter(
['4071', '274', '1174', '278', '2'])),
[1.0, 0.0, 0.0, 0.0, 0.0])
def testKnn(self):
self.assertEqual(
list(
self.graph.average_neighbor_degrees_iter(
['2', '274', '1174', '278'])),
[1.2112211221122111, 0.0, 870.0, 0.0])
def testKcorenessIterPartial1(self):
self.assertEqual(list(self.graph.kcoreness_iter(['2', '1174'])),
[4, 1])
def testKcorenessIterPartial2(self):
self.assertEqual(list(self.graph.kcoreness_iter(['3', '4', '5'])),
[4, 4, 4])
def testTriangles(self):
#self.graph = BigGraph()
#self.graph.create_indices()
self.graph.add_edge('2', '1234000')
self.graph.add_edge('1234000', '1234001')
self.graph.add_edge('1234001', '2')
self.graph.add_edge('2', '1')
self.graph.add_edge('1', '1234001')
self.graph.add_edge('1234001', '2')
self.graph.add_edge('2', '1234003')
self.graph.add_edge('1234003', '1234004')
self.graph.add_edge('1234004', '2')
self.graph.add_edge('2', '1234003')
self.graph.add_edge('1234003', '1234006')
self.graph.add_edge('1234006', '2')
self.graph.create_index_triangles()
self.assertEqual(
list(self.graph.triangles_iter(['2', '274', '1174', '278'])),
[4, 0, 0, 0])
class BigPrivacyStressTest4(unittest.TestCase):
def setUp(self):
pass
self.graph = BigGraph()
self.graph.debug = False
self.graph.max_links_input = 5000
self.graph.input_debug_links = 200000
self.graph.output_debug_nodes = 500
use_big_alphabet = False
self.graph.load_compressed_graph(cloudlight.tests.data_enc1, use_big_alphabet)
self.graph.create_indices()
self.graph.remove_degree_cache()
self.graph.create_index_degree()
self.graph.index_parameter_from_degree('unseen_degree')
lookahead = 1
coverage = 'korolova node'
self.strategies = PrivacyAttackStrategies(self.graph, lookahead, coverage, self.graph.debug)
self.coverages = [0.80] # [ float(f)/100 for f in range(2, 104, 2) ]
def testStrategyRandom(self):
random.seed(6661)
self.assertEqual( list(self.strategies.start_random([0.01]))[0], 1)
def testStrategyDegree(self):
random.seed(6662)
self.assertEqual( list(self.strategies.start_degree(self.coverages))[0], 3)
def testStrategyGreedy(self):
random.seed(6663)
self.assertEqual( list(self.strategies.start_greedy(self.coverages))[0], 3)
def testStrategyCrawler(self):
random.seed(6664)
self.assertEqual( list(self.strategies.start_crawler(self.coverages))[0], 3)
def testStrategySupernodeRandom(self):
random.seed(666)
#self.assertEqual( list(self.strategies.start_supernode_random([0.01]))[0], 51)
def testStrategySupernodeDegree(self):
random.seed(6667)
self.assertEqual( list(self.strategies.start_supernode_degree(self.coverages))[0], 4)
def testStrategySupernodeGreedy(self):
random.seed(6668)
self.assertEqual( list(self.strategies.start_supernode_greedy(self.coverages))[0], 4)
def testStrategySupernodeCrawler(self):
random.seed(6669)
self.assertEqual( list(self.strategies.start_supernode_crawler(self.coverages))[0], 5)
def testStrategyTriangles(self):
self.graph.create_index_triangles()
random.seed(7777)
self.coverages = [0.20]
self.assertEqual( list(self.strategies.start_triangles(self.coverages))[0], 531)
def testStrategyTrianglesCoverage(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.max_links_input = 40000 #5000
self.graph.input_debug_links = 200000
self.graph.output_debug_nodes = 500
use_big_alphabet = False
self.graph.load_compressed_graph(cloudlight.tests.data_enc1, use_big_alphabet)
self.graph.create_indices()
self.graph.remove_degree_cache()
self.graph.create_index_degree()
self.graph.index_parameter_from_degree('unseen_degree')
lookahead = 1
coverage = 'korolova node'
self.strategies = PrivacyAttackStrategies(self.graph, lookahead, coverage, self.graph.debug)
self.coverages = [0.80] # [ float(f)/100 for f in range(2, 104, 2) ]
self.graph.create_index_triangles()
self.graph.index_parameter_from_parameter('triangles', 'unseen_triangles')
random.seed(7777)
self.graph.add_edge(1234000, 1234001)
self.graph.add_edge(1234001, 1234002)
self.graph.add_edge(1234002, 1234000)
self.graph.add_edge(1234000, 1234001)
self.graph.add_edge(1234001, 1234003)
self.graph.add_edge(1234003, 1234000)
coverage = 'triangle'
lookahead = 1
self.strategies = PrivacyAttackStrategies(self.graph, lookahead, coverage, self.graph.debug)
self.coverages = [0.80]
self.assertEqual( list(self.strategies.start_triangles(self.coverages))[0], 28)
class Test(unittest.TestCase):
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
self.graph.load_edgelist(StringIO(example_txt2))
self.graph.create_indices()
self.graph.create_index_degree()
self.graph.create_index_triangles()
self.graph.create_index_unseen_degree()
self.graph.index_parameter_from_parameter('triangles', 'unseen_triangles')
self.graph.add_parameter_cache('seen_degree')
self.graph.initialize_parameter('seen_degree', 0.0)
self.graph.index_parameter_cache('seen_degree')
self.graph.add_parameter_cache('seen_degree2')
self.graph.initialize_parameter('seen_degree2', 0.0)
self.graph.index_parameter_cache('seen_degree2')
self.graph.add_parameter_cache('seen_triangles')
self.graph.initialize_parameter('seen_triangles', 0.0)
self.graph.index_parameter_cache('seen_triangles')
self.graph.add_parameter_cache('seen_triangles2')
self.graph.initialize_parameter('seen_triangles2', 0.0)
self.graph.index_parameter_cache('seen_triangles2')
self.privacy_model = LinkPrivacyModel(self.graph, 1)
self.privacy_model.coverage_types = ['node','korolova','link','triangle']
def setUp2(self):
self.privacy_model.add_bribed_node('RCARecords')
self.assertTrue('RCARecords' in self.privacy_model.graph.nodes_iter() )
self.assertTrue(not 'RCARecords' in self.privacy_model.agents )
self.assertTrue('RCARecords' in self.privacy_model.controlled_nodes )
self.assertAlmostEqual(self.privacy_model.bribe_effort, 1)
self.assertAlmostEqual(self.privacy_model.total_effort(), 1)
self.privacy_model.strategy = 'start_crawler'
self.privacy_model.add_bribed_node('foofighters')
def tearDown(self):
pass
# def testAddRogueNode(self):
#
# pass
#
# def testCoverage(self):
#
# self.setUp2()
#
# self.assertEqual( self.privacy_model.link_coverage(), 0.51162790697674421)
#
#
# def testMaxUnseenDegreeNode(self):
#
# self.setUp2()
#
# self.assertEqual( self.privacy_model.max_unseen_degree_node(), 'Egger3rd')
#
#
# def testMaxUnseenDegreeCrawlerNode(self):
#
# self.setUp2()
#
# self.privacy_model.add_bribed_node('Egger3rd')
#
# self.assertEqual( self.privacy_model.max_unseen_degree_crawler_node(), 'cjweeks')
#
#
# def testSortedDegreesDec(self):
#
# self.assertEqual( list(self.privacy_model.sorted_degrees_dec_iter())[:4], ['ABadFeeling', 'Egger3rd', 'cjweeks', 'foofighters'])
# self.assertEqual( sorted(list(self.privacy_model.sorted_degrees_dec_iter())), sorted(list(set( self.privacy_model.sorted_degrees_dec_iter() ))) )
def setUp3(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
edge = self.graph.add_edge
a,b,c,d,e,f,g,h,i = 'a','b','c','d','e','f','g','h','i'
edge(a,b)
edge(b,c)
edge(c,e)
edge(c,d)
edge(d,e)
edge(b,d)
edge(a,f)
edge(a,g)
edge(a,h)
edge(a,i)
edge(g,h)
edge(h,i)
self.graph.create_indices()
self.graph.create_index_degree()
self.graph.create_index_triangles()
self.graph.create_index_unseen_degree()
self.graph.index_parameter_from_parameter('triangles', 'unseen_triangles')
self.graph.add_parameter_cache('seen_degree')
self.graph.initialize_parameter('seen_degree', 0.0)
self.graph.index_parameter_cache('seen_degree')
self.graph.add_parameter_cache('seen_degree2')
self.graph.initialize_parameter('seen_degree2', 0.0)
self.graph.index_parameter_cache('seen_degree2')
self.graph.add_parameter_cache('seen_triangles')
self.graph.initialize_parameter('seen_triangles', 0.0)
self.graph.index_parameter_cache('seen_triangles')
self.graph.add_parameter_cache('seen_triangles2')
self.graph.initialize_parameter('seen_triangles2', 0.0)
self.graph.index_parameter_cache('seen_triangles2')
self.privacy_model = LinkPrivacyModel(self.graph, 1)
self.privacy_model.coverage_types = ['node','korolova','link','triangle']
self.privacy_model.initialize_histogram_degree(number_of_nodes=self.graph.number_of_nodes())
self.privacy_model.strategy = 'start_crawler_degree_hist'
def testBribedNodeRecursive(self):
self.setUp3()
g = self.graph
self.assertEqual( g.get_parameter_cache('seen_degree', 'a') , 0 )
self.assertEqual( g.get_parameter_cache('seen_degree2', 'a') , 0 )
self.assertEqual( g.get_parameter_cache('unseen_degree', 'a') , 5 )
self.assertEqual( g.get_parameter_cache('seen_triangles', 'a') , 0 )
self.assertEqual( g.get_parameter_cache('seen_triangles2', 'a') , 0 )
self.assertEqual( g.get_parameter_cache('unseen_triangles', 'a') , 2 )
self.assertEqual( g.get_parameter_cache('seen_degree', 'b') , 0 )
self.assertEqual( g.get_parameter_cache('seen_degree2', 'b') , 0 )
self.assertEqual( g.get_parameter_cache('unseen_degree', 'b') , 3 )
self.assertEqual( g.get_parameter_cache('seen_triangles', 'b') , 0 )
self.assertEqual( g.get_parameter_cache('seen_triangles2', 'b') , 0 )
self.assertEqual( g.get_parameter_cache('unseen_triangles', 'b') , 1 )
self.assertEqual( self.privacy_model.M, [9, 0, 0, 0, 0, 0] )
#print 'SOBORNANDO NODO "a"'
self.privacy_model.add_bribed_node('a')
self.assertEqual( g.get_parameter_cache('seen_degree', 'a') , -1 )
self.assertEqual( g.get_parameter_cache('seen_degree2', 'a') , 5 )
self.assertEqual( g.get_parameter_cache('unseen_degree', 'a') , 0 )
self.assertEqual( g.get_parameter_cache('seen_triangles', 'a') , 2 )
self.assertEqual( g.get_parameter_cache('seen_triangles2', 'a') , -1 )
self.assertEqual( g.get_parameter_cache('unseen_triangles', 'a') , 0 )
self.assertEqual( g.get_parameter_cache('seen_degree', 'b') , -1 )
self.assertEqual( g.get_parameter_cache('seen_degree2', 'b') , 3 )
self.assertEqual( g.get_parameter_cache('unseen_degree', 'b') , 0 )
self.assertEqual( g.get_parameter_cache('seen_triangles', 'b') , 0 )
self.assertEqual( g.get_parameter_cache('seen_triangles2', 'b') , 0 )
self.assertEqual( g.get_parameter_cache('unseen_triangles', 'b') , 1 )
self.assertEqual( self.privacy_model.M, [1, 3, 2, 2, 0, 1] )
#print 'SOBORNANDO NODO "a"'
self.privacy_model.add_bribed_node('b')
self.assertEqual( g.get_parameter_cache('seen_degree', 'b') , -1 )
self.assertEqual( g.get_parameter_cache('seen_degree2', 'b') , 3 )
self.assertEqual( g.get_parameter_cache('unseen_degree', 'b') , 0 )
self.assertEqual( g.get_parameter_cache('seen_triangles', 'b') , 1 )
self.assertEqual( g.get_parameter_cache('seen_triangles2', 'b') , -1 )
self.assertEqual( g.get_parameter_cache('unseen_triangles', 'b') , 0 )
self.assertEqual( self.privacy_model.M, [0, 1, 3, 4, 0, 1] )
self.assertEqual( self.privacy_model.link_coverage(), 1.0 )
class BigPrivacyStressTest3(unittest.TestCase):
def setUp(self):
debug = False
self.graph = BigGraph()
self.graph.debug = debug
self.graph.max_links_input = 100000
self.graph.input_debug_links = 200000
self.graph.output_debug_nodes = 10000
use_big_alphabet = False
self.graph.load_compressed_graph(cloudlight.tests.data_enc1, use_big_alphabet)
self.graph.create_indices()
self.graph.create_index_degree()
self.graph.create_index_unseen_degree()
self.graph.create_index_triangles()
lookahead = 1
coverage = 'korolova node'
self.strategies = PrivacyAttackStrategies(self.graph, lookahead, coverage, debug)
self.coverages = [0.1] # [ float(f)/100 for f in range(2, 104, 2) ]
def testStrategyRandom(self):
#random.seed(6661)
#self.assertEqual( list(self.strategies.start_random([0.01]))[0], 266)
pass
def testStrategyDegree(self):
random.seed(6662)
self.assertEqual( list(self.strategies.start_degree(self.coverages))[0], 4)
def testStrategyGreedy(self):
random.seed(6663)
self.assertEqual( list(self.strategies.start_greedy(self.coverages))[0], 4)
def testStrategyCrawler(self):
random.seed(6664)
self.assertEqual( list(self.strategies.start_crawler(self.coverages))[0], 4)
def testStrategySupernodeRandom(self):
#random.seed(6665)
#self.assertEqual( list(self.strategies.start_supernode_random([0.01]))[0], 283)
pass
def testStrategySupernodeDegree(self):
self.assertEqual( list(self.strategies.start_supernode_degree(self.coverages))[0], 6)
def testStrategySupernodeGreedy(self):
self.assertEqual( list(self.strategies.start_supernode_greedy(self.coverages))[0], 6)
def testStrategySupernodeCrawler(self):
self.assertEqual( list(self.strategies.start_supernode_crawler(self.coverages))[0], 16)
class Test(unittest.TestCase):
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
self.graph.load_edgelist(StringIO(example_txt2))
self.graph.create_indices()
self.graph.create_index_degree()
self.graph.create_index_unseen_degree()
self.graph.create_index_triangles()
self.privacy_model = LinkPrivacyModel(self.graph, 1)
def setUp2(self):
self.privacy_model.add_bribed_node('RCARecords')
self.assertTrue(
'RCARecords' in list(self.privacy_model.graph.nodes_iter()))
self.assertTrue('RCARecords' in self.privacy_model.controlled_nodes)
self.assertAlmostEqual(self.privacy_model.bribe_effort, 1)
self.assertAlmostEqual(self.privacy_model.total_effort(), 1)
def tearDown(self):
pass
def testAddBribedNode(self):
self.setUp2()
self.assertEqual(self.privacy_model.korolova_node_coverage(),
0.045454545454545456)
self.privacy_model.add_bribed_node('jcl5m')
self.assertEqual(self.privacy_model.korolova_node_coverage(),
0.47727272727272729)
def testAddRogueNode(self):
self.privacy_model.add_rogue_node('Rogue1')
self.assertEqual(self.privacy_model.controlled_nodes, set(['Rogue1']))
self.assertTrue(
'Rogue1' in list(self.privacy_model.graph.nodes_iter()))
self.assertEqual(list(self.privacy_model.graph.edges_iter('Rogue1')),
[])
self.assertEqual(list(self.privacy_model.graph.edges_iter('Rogue1')),
[])
self.assertAlmostEqual(self.privacy_model.rogue_effort, 1)
def testMaxUnseenDegreeNode(self):
self.setUp2()
self.assertEqual(self.privacy_model.max_unseen_degree_node(),
'ABadFeeling')
def testMaxUnseenDegreeCrawlerNode(self):
self.setUp2()
self.privacy_model.add_bribed_node('Egger3rd')
self.assertEqual(self.privacy_model.max_unseen_degree_crawler_node(),
'cjweeks')
def testSortedDegreesDec(self):
self.assertEqual(
list(self.privacy_model.sorted_degrees_dec_iter())[:2],
['ABadFeeling', 'Egger3rd'])
def testActiveAttack(self):
self.graph = BigGraph()
g = self.graph
g.add_edge('3', '1')
g.add_edge('4', '1')
g.add_edge('5', '1')
g.add_edge('6', '5')
g.add_edge('2', '7')
g.add_edge('8', '2')
g.add_edge('9', '2')
self.assertEqual(list(self.graph.neighbors_iter('1')),
[u'3', u'4', u'5'])
self.graph.create_indices()
self.graph.create_index_degree()
self.graph.create_index_unseen_degree()
self.privacy_model = LinkPrivacyModel(self.graph, 2)
self.privacy_model.add_bribed_node('5')
self.assertEqual(self.privacy_model.korolova_node_coverage(),
0.55555555555555558)
self.privacy_model.add_false_link('1', '2')
self.assertEqual(set(self.graph.neighbors_iter('1')),
set([
u'3',
u'4',
u'5',
u'2',
]))
self.assertEqual(self.privacy_model.korolova_node_coverage(), 1.0)
def testHistogram(self):
self.privacy_model.initialize_histogram_degree(
degree_dist=lambda x: 0.677 * x**-2.33, number_of_nodes=100000)
@author: jose
'''
import sys
from cloudlight.classes.big_graph import BigGraph
from cloudlight.algorithms.plot import Plot
filename = len(sys.argv) > 1 and sys.argv[1] or None
if not filename:
#filename = '/tesis/flickr-growth.txt-200k.big_graph'
print 'Error: first argument missing, input filename with space separated graph!'
exit(-1)
graph = BigGraph(filename)
debug = True
graph.debug = debug
#graph.input_debug_links = 200000
graph.output_debug_nodes = 10000
#graph.max_links_input = 5*10**4
#graph.max_nodes_analysis = 10000
folder = len(sys.argv) > 2 and sys.argv[2] or None
if not folder:
#folder = '/tesis/flickr-growth.txt-200k.big_graph.analysis'
print 'Error: second argument missing, output folder name!'
class Test(unittest.TestCase):
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.max_links_input = 50000
self.graph.input_debug_links = 1000 #200000
self.graph.output_debug_nodes = 10000
use_big_alphabet = False
self.graph.load_compressed_graph(cloudlight.tests.data_enc1,
use_big_alphabet, False)
self.graph.create_indices()
def tearDown(self):
pass
def testDegreeParam(self):
self.graph.create_index_degree()
sum = 0
for _, value in self.graph.get_parameter_cache_iter('degree'):
sum += value
self.assertEqual(sum, 100000.0)
def testClusteringParam(self):
self.graph.create_index_clustering()
sum = 0
for _, value in self.graph.get_parameter_cache_iter('clustering'):
sum += value
self.assertAlmostEqual(sum, 1290.6523256023384)
def testKnnParam(self):
self.graph.create_index_knn()
sum = 0
for _, value in self.graph.get_parameter_cache_iter('knn'):
sum += value
self.assertAlmostEqual(sum, 14815770.85218275)
def testDegreeInverse(self):
self.graph.create_index_degree()
deg_one_nodes = list(
self.graph.get_parameter_cache_inverse('degree', 1))
self.assertEqual(len(deg_one_nodes), 38702)
def testKnnInverse(self):
self.graph.create_index_knn()
deg_one_nodes = list(self.graph.get_parameter_cache_inverse(
'knn', 139))
self.assertEqual(len(deg_one_nodes), 381)
def testClusteringInverse(self):
self.graph.create_index_clustering()
deg_one_nodes = list(
self.graph.get_parameter_cache_inverse('clustering', 0.666666))
self.assertEqual(len(deg_one_nodes), 97)
def testGetClustering(self):
self.graph.create_index_clustering()
deg_one_nodes = list(
self.graph.get_parameter_cache_inverse('clustering', 0.666666))
node = list(deg_one_nodes)[0]
self.assertAlmostEqual(
self.graph.get_parameter_cache('clustering', node), 0.66666666666)
def testCountSphere4(self):
g = BigGraph()
g.add_node('e')
g.add_node('a')
g.add_node('b')
g.add_node('c')
g.add_node('f')
g.add_node('d')
g.add_node('g')
g.add_edge( 'a', 'c' )
g.add_edge( 'c', 'b' )
g.add_edge( 'c', 'd' )
g.add_edge( 'a', 'f' )
g.add_edge( 'd', 'e' )
g.add_edge( 'b', 'g' )
self.assertEqual( g.count_edges_lookahead('c', 0), g.degree('c'))
self.assertEqual( g.count_edges_lookahead('c', 1), 6)
class Test(unittest.TestCase):
def setUp(self):
self.graph = BigGraph()
self.graph.debug = False
self.graph.input_debug_links = 1
self.graph.output_debug_nodes = 1
self.graph.create_indices()
self.graph.create_index_clustering()
self.graph.create_index_degree()
self.graph.create_index_knn()
self.graph.load_edgelist(StringIO(example_txt), num=False)
def tearDown(self):
pass
def testNodes(self):
nodes = list(self.graph.nodes_iter())
self.assertEqual( nodes, [u'1', u'2', u'3', u'4', u'5', u'6', u'666', u'7', u'8', u'9'])
def testEdges(self):
edges = list(self.graph.edges_iter())
self.assertEqual( len(edges), 8)
edges = list(self.graph.edges_iter('9'))
self.assertEqual( len(edges), 3)
def testEdgesBunch(self):
edges = list(self.graph.edges_iter(['1','4']))
self.assertEqual( len(edges), 2)
def testDegrees(self):
self.assertEqual(list(self.graph.degrees_iter()), [1, 1, 1, 1, 2, 1, 1, 3, 2, 3])
def testDegreesPartial(self):
self.assertEqual(list(self.graph.degrees_iter(['2','3','4'])), [1, 1, 1])
def testClustering(self):
pass
#self.assertEqual( list(self.graph.clustering_indices_iter()), [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.33333333333333331, 1.0, 0.33333333333333331])
def testKnn(self):
self.assertEqual(list(self.graph.average_neighbor_degrees()), [1.0, 1.0, 2.0, 2.0, 1.0, 3.0, 3.0, 2.0, 3.0, 2.0])
def testKcorenessIterPartial(self):
self.assertEqual(list(self.graph.kcoreness_iter(['3', '4', '5'])), [1, 1, 1])
def testEdgeWeight(self):
self.assertEqual( self.graph.degree( '1' ), 1 )
self.graph.update_edge_weight('1', '2', 0)
self.assertEqual( self.graph.degree( '1' ), 0 )
self.assertEqual( self.graph.degree( '1', 0 ), 1 )
def testCountSphere(self):
pass
# self.assertEqual( self.graph.count_edges_lookahead('1', 0), self.graph.degree('1'))
# self.assertEqual( self.graph.count_edges_lookahead('1', 1), 1)
# self.graph.add_edge('2', '34')
# self.graph.add_edge('2', '35')
# self.assertEqual( self.graph.count_edges_lookahead('1', 1), 3)
# self.assertEqual( self.graph.count_edges_lookahead('1', 2), 3)
# self.graph.add_edge('34', '35')
# self.assertEqual( self.graph.count_edges_lookahead('1', 2), 4)
# self.graph.add_edge('34', '3435')
# self.graph.add_edge('34', '3436')
# self.graph.add_edge('3435', '3436')
# self.assertEqual( self.graph.count_edges_lookahead('1', 2), 6)
# self.assertEqual( self.graph.count_edges_lookahead('1', 3), 7)
def testCountSphere2(self):
self.assertEqual( self.graph.count_nodes_lookahead('1', 0), 2)
self.assertEqual( self.graph.count_nodes_lookahead('1', 1), 2)
self.graph.add_edge('2', '34')
self.graph.add_edge('2', '35')
self.assertEqual( self.graph.count_nodes_lookahead('1', 1), 4)
self.assertEqual( self.graph.count_nodes_lookahead('1', 2), 4)
self.graph.add_edge('34', '35')
self.assertEqual( self.graph.count_nodes_lookahead('1', 2), 4)
self.graph.add_edge('34', '3435')
self.graph.add_edge('34', '3436')
self.assertEqual( self.graph.count_nodes_lookahead('1', 2), 6)
self.assertEqual( self.graph.count_nodes_lookahead('1', 3), 6)
def testCountSphere3(self):
g = BigGraph()
g.add_node('a')
g.add_node('b')
g.add_node('c')
g.add_node('d')
g.add_edge( 'a', 'c' )
g.add_edge( 'c', 'b' )
g.add_edge( 'c', 'd' )
self.assertEqual( g.count_edges_lookahead('c', 0), g.degree('c'))
self.assertEqual( g.count_edges_lookahead('c', 1), g.degree('c'))
def testSphereIndices(self):
self.graph.create_index_nodesphere(0)
self.graph.create_index_nodesphere(1)
self.graph.create_index_nodesphere(2)
self.graph.create_index_nodesphere(3)
self.graph.create_index_linksphere(0)
self.graph.create_index_linksphere(1)
self.graph.create_index_linksphere(2)
self.graph.create_index_linksphere(3)
def testCountSphere4(self):
g = BigGraph()
g.add_node('e')
g.add_node('a')
g.add_node('b')
g.add_node('c')
g.add_node('f')
g.add_node('d')
g.add_node('g')
g.add_edge( 'a', 'c' )
g.add_edge( 'c', 'b' )
g.add_edge( 'c', 'd' )
g.add_edge( 'a', 'f' )
g.add_edge( 'd', 'e' )
g.add_edge( 'b', 'g' )
self.assertEqual( g.count_edges_lookahead('c', 0), g.degree('c'))
self.assertEqual( g.count_edges_lookahead('c', 1), 6)
def testTotalTriangles(self):
self.graph = BigGraph()
self.graph.create_indices()
self.graph.add_edge(1234000, 1234001)
self.graph.add_edge(1234001, 1234002)
self.graph.add_edge(1234002, 1234000)
self.graph.add_edge(1234000, 1234001)
self.graph.add_edge(1234001, 1234003)
self.graph.add_edge(1234003, 1234000)
self.graph.create_index_triangles()
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234000), 2)
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234001), 2)
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234002), 1)
self.assertEqual(self.graph.get_parameter_cache('triangles', 1234003), 1)
self.assertEqual(self.graph.total_triangles(), 2)
self.assertEqual(self.graph.total_triangles_weight(1), 2)
self.assertEqual(self.graph.total_triangles_weight(2), 0)
self.assertEqual(self.graph.triangles_weight(1234000, 1), 2)
self.assertEqual(self.graph.triangles_weight(1234000, 2), 0)
self.assertEqual(self.graph.triangles_weight(6756443, 1), 0)
self.assertEqual(self.graph.triangles_weight(6756443, 2), 0)
