def avg_out_degree_over_time(): avg_out_degrees = {} graph = nx.MultiDiGraph() for end_day in graphgen._days: start = int(str(end_day) + "000000") end = int(str(end_day) + "235959") graph = graphgen.add_slice_to_graph(graph, start, end) avg_out_deg = graphtools.get_avg_out_degree_from_graph(graph) avg_out_degrees[end_day] = avg_out_deg print end_day, avg_out_deg utils.save_node_map(avg_out_degrees, ("avg_out_degrees"))
def frac_nodes_in_gcc_over_time(): frac_nodes_in_gcc = {} graph = nx.MultiDiGraph() for end_day in graphgen._days: start = int(str(end_day) + "000000") end = int(str(end_day) + "235959") graph = graphgen.add_slice_to_graph(graph, start, end) frac_nodes = graphtools.get_frac_nodes_in_gcc_from_graph(graph) frac_nodes_in_gcc[end_day] = frac_nodes print end_day, frac_nodes utils.save_node_map(frac_nodes_in_gcc, ("frac_nodes_in_gcc"))
def effective_diameter_over_time(): effective_diameters = {} graph = nx.MultiDiGraph() for end_day in graphgen._days: start = int(str(end_day) + "000000") end = int(str(end_day) + "235959") graph = graphgen.add_slice_to_graph(graph, start, end) effective_diam = graphtools.effective_diameter(graph) effective_diameters[end_day] = effective_diam print end_day, effective_diam utils.save_node_map(effective_diameters, ("effective_diameters"))
def user_sell_frequency(g, stamp=''): """Same as above, but considers in degree, or when the node is payed, ie sells something in exchange for bitcoins. """ frequency = {} node_to_freq = {} for node in g.nodes(): freq = g.in_degree(node) frequency[freq] = frequency[freq] + 1 if frequency.get(freq) else 1 node_to_freq[node] = freq utils.save_node_map(node_to_freq, 'node_sell_freq_'+stamp)
def user_sell_frequency(g, stamp=''): """Same as above, but considers in degree, or when the node is payed, ie sells something in exchange for bitcoins. """ frequency = {} node_to_freq = {} for node in g.nodes(): freq = g.in_degree(node) frequency[freq] = frequency[freq] + 1 if frequency.get(freq) else 1 node_to_freq[node] = freq utils.save_node_map(node_to_freq, 'node_sell_freq_' + stamp)
def user_buy_frequency(g, stamp=''): """Same as first method, but now for the frequency in which a user spends money, ie out degree """ frequency = {} node_to_freq = {} for node in g.nodes(): freq = g.out_degree(node) frequency[freq] = frequency[freq] + 1 if frequency.get(freq) else 1 node_to_freq[node] = freq utils.save_node_map(node_to_freq, 'node_buy_freq_' + stamp) utils.save_node_map(frequency, 'freq_to_buy_' + stamp)
def user_buy_frequency(g, stamp=''): """Same as first method, but now for the frequency in which a user spends money, ie out degree """ frequency = {} node_to_freq = {} for node in g.nodes(): freq = g.out_degree(node) frequency[freq] = frequency[freq] + 1 if frequency.get(freq) else 1 node_to_freq[node] = freq utils.save_node_map(node_to_freq, 'node_buy_freq_'+stamp) utils.save_node_map(frequency, 'freq_to_buy_'+stamp)
def avg_out_degree_over_time(): slices = graphgen.generate_weighted_time_slices() avg_out_degrees_r = {} avg_out_dgree_p = {} for start, end in slices: n, m = _node_and_edges(start, end) if n == 0: continue rg = nx.gnm_random_graph(n, m, directed=True) pfg = nx.barabasi_albert_graph(n, m/n) avg_out_deg = graphtools.get_avg_out_degree_from_graph(rg) avg_out_degrees_r[start] = avg_out_deg avg_out_deg = graphtools.get_avg_out_degree_from_graph(pfg) avg_out_degrees_p[start] = avg_out_deg utils.save_node_map(avg_out_degrees_r, ("avg_out_degrees_r")) utils.save_node_map(avg_out_degrees_p, ("avg_out_degrees_p"))
def user_transaction_frequency(g, stamp=''): """ Takes in a graph representing a snippet of the bitcoin network and graphs a representation of each user's transaction frequency. Creates two dicts: one with a frequency mapped to the number of nodes with that amount. The other maps a specific node to its frequency. The stamp should be something to append to the outputed csv so we know which graph snippet the data refers to. """ frequency = {} node_to_freq = {} for node in g.nodes(): freq = len(g.neighbors(node)) frequency[freq] = frequency[freq] + 1 if frequency.get(freq) else 1 node_to_freq[node] = freq utils.save_node_map(node_to_freq, 'node_transaction_freq_' + stamp) utils.save_node_map(frequency, 'freq_to_transaction_' + stamp) # plot_node_data.plot_node_map(node_to_freq) return frequency
def avg_out_degree_over_time(): slices = graphgen.generate_weighted_time_slices() avg_out_degrees_r = {} avg_out_dgree_p = {} for start, end in slices: n, m = _node_and_edges(start, end) if n == 0: continue rg = nx.gnm_random_graph(n, m, directed=True) pfg = nx.barabasi_albert_graph(n, m / n) avg_out_deg = graphtools.get_avg_out_degree_from_graph(rg) avg_out_degrees_r[start] = avg_out_deg avg_out_deg = graphtools.get_avg_out_degree_from_graph(pfg) avg_out_degrees_p[start] = avg_out_deg utils.save_node_map(avg_out_degrees_r, ("avg_out_degrees_r")) utils.save_node_map(avg_out_degrees_p, ("avg_out_degrees_p"))
def user_transaction_frequency(g, stamp=''): """ Takes in a graph representing a snippet of the bitcoin network and graphs a representation of each user's transaction frequency. Creates two dicts: one with a frequency mapped to the number of nodes with that amount. The other maps a specific node to its frequency. The stamp should be something to append to the outputed csv so we know which graph snippet the data refers to. """ frequency = {} node_to_freq = {} for node in g.nodes(): freq = len(g.neighbors(node)) frequency[freq] = frequency[freq] + 1 if frequency.get(freq) else 1 node_to_freq[node] = freq utils.save_node_map(node_to_freq, 'node_transaction_freq_'+stamp) utils.save_node_map(frequency, 'freq_to_transaction_'+stamp) # plot_node_data.plot_node_map(node_to_freq) return frequency
def user_transaction_amount(g, stamp=''): """Takes in a graph representing a snippet of the bitcoin network and graphs a representation of the amount of bitcoins passing through a user. Also maps the frequency of that amount by rounding amounts in a specific digit position. TODO: decide if it should be spent, recieved, all, or some combination """ amount_frequency = {} node_to_amount = {} for node in g.nodes(): total = 0.0 for s, e, d in g.edges(node, data=True): total += d['value'] node_to_amount[node] = total rounded = int(total * _ROUND_FACTOR) / float(_ROUND_FACTOR) amount_frequency[rounded] = amount_frequency[rounded] + 1 if \ amount_frequency.get(rounded) else 1 utils.save_node_map(node_to_amount, 'node_transaction_amount_'+stamp) utils.save_node_map(amount_frequency, 'amount_to_frequency_'+stamp)
def user_transaction_amount(g, stamp=''): """Takes in a graph representing a snippet of the bitcoin network and graphs a representation of the amount of bitcoins passing through a user. Also maps the frequency of that amount by rounding amounts in a specific digit position. TODO: decide if it should be spent, recieved, all, or some combination """ amount_frequency = {} node_to_amount = {} for node in g.nodes(): total = 0.0 for s, e, d in g.edges(node, data=True): total += d['value'] node_to_amount[node] = total rounded = int(total * _ROUND_FACTOR) / float(_ROUND_FACTOR) amount_frequency[rounded] = amount_frequency[rounded] + 1 if \ amount_frequency.get(rounded) else 1 utils.save_node_map(node_to_amount, 'node_transaction_amount_' + stamp) utils.save_node_map(amount_frequency, 'amount_to_frequency_' + stamp)
def all_computations(): slices = graphgen.generate_weighted_time_slices() avg_out_degrees = {} frac_nodes_in_gcc = {} num_nodes = [] num_edges = [] for i in range(len(slices)): print i, " slices out of ", len(slices) start, end = slices[i] g = cv_from_btc(start, end) if len(g) == 0: continue num_nodes.append(g.number_of_nodes()) num_edges.append(g.number_of_edges()) avg_out_deg = graphtools.get_avg_out_degree_from_graph(g) avg_out_degrees[start] = avg_out_deg frac_nodes = graphtools.get_frac_nodes_in_gcc_from_graph(g) frac_nodes_in_gcc[start] = frac_nodes utils.save_node_map(avg_out_degrees, ("avg_out_degrees_model")) utils.save_node_map(frac_nodes_in_gcc, ("frac_nodes_in_gcc_model")) utils.save_lists(num_nodes, num_edges, ("nodes_vs_edges_model"))
def all_computations(): slices = graphgen.generate_weighted_time_slices() avg_out_degrees_r = {} # effective_diameters_p = {} # effective_diameters_r = {} frac_nodes_in_gcc_p = {} frac_nodes_in_gcc_r = {} i = 0 for start, end in slices: print 'slice %s of %s' % (i, len(slices)) n, m = _node_and_edges(start, end) if n == 0: continue rg = nx.gnm_random_graph(n, m, directed=True) pfg = nx.barabasi_albert_graph(n, m/n) avg_out_deg = graphtools.get_avg_out_degree_from_graph(rg) avg_out_degrees_r[start] = avg_out_deg # effective_diam = graphtools.effective_diameter(rg) # effective_diameters_r[start] = effective_diam # effective_diam = graphtools.effective_diameter(pfg) # effective_diameters_p[start] = effective_diam frac_nodes = graphtools.get_frac_nodes_in_gcc_from_graph(rg) frac_nodes_in_gcc_r[start] = frac_nodes frac_nodes = graphtools.get_frac_nodes_in_gcc_from_graph(pfg) frac_nodes_in_gcc_p[start] = frac_nodes utils.save_node_map(avg_out_degrees_r, ("avg_out_degrees_r")) # utils.save_node_map(effective_diameters_r, ("effective_diameters_r")) # utils.save_node_map(effective_diameters_p, ("effective_diameters_p")) utils.save_node_map(frac_nodes_in_gcc_r, ("frac_nodes_in_gcc_r")) utils.save_node_map(frac_nodes_in_gcc_p, ("frac_nodes_in_gcc_p"))
def all_computations(): slices = graphgen.generate_weighted_time_slices() avg_out_degrees_r = {} # effective_diameters_p = {} # effective_diameters_r = {} frac_nodes_in_gcc_p = {} frac_nodes_in_gcc_r = {} i = 0 for start, end in slices: print 'slice %s of %s' % (i, len(slices)) n, m = _node_and_edges(start, end) if n == 0: continue rg = nx.gnm_random_graph(n, m, directed=True) pfg = nx.barabasi_albert_graph(n, m / n) avg_out_deg = graphtools.get_avg_out_degree_from_graph(rg) avg_out_degrees_r[start] = avg_out_deg # effective_diam = graphtools.effective_diameter(rg) # effective_diameters_r[start] = effective_diam # effective_diam = graphtools.effective_diameter(pfg) # effective_diameters_p[start] = effective_diam frac_nodes = graphtools.get_frac_nodes_in_gcc_from_graph(rg) frac_nodes_in_gcc_r[start] = frac_nodes frac_nodes = graphtools.get_frac_nodes_in_gcc_from_graph(pfg) frac_nodes_in_gcc_p[start] = frac_nodes utils.save_node_map(avg_out_degrees_r, ("avg_out_degrees_r")) # utils.save_node_map(effective_diameters_r, ("effective_diameters_r")) # utils.save_node_map(effective_diameters_p, ("effective_diameters_p")) utils.save_node_map(frac_nodes_in_gcc_r, ("frac_nodes_in_gcc_r")) utils.save_node_map(frac_nodes_in_gcc_p, ("frac_nodes_in_gcc_p"))