1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
|
# cython: boundscheck=False, cdivision=True
import numpy as np
cimport numpy as np
from libc.math cimport log, exp
DTYPE = np.float64
ctypedef np.float_t DTYPE_t
cdef DTYPE_t weight_success(int dist, int dt, DTYPE_t alpha,
DTYPE_t delta, DTYPE_t gamma):
"""weight for successful infection, exponential time model"""
cdef DTYPE_t structural, temporal, result
structural = delta ** (dist)
temporal = exp(-alpha * dt) * (1 - exp(-alpha))
result = log(structural * temporal)
return result
cdef DTYPE_t weight_success_power(int dist, int dt, DTYPE_t alpha,
DTYPE_t delta, DTYPE_t gamma):
"""weight for successful infection, power-law time model"""
cdef DTYPE_t structural, temporal, result
structural = delta ** (dist)
temporal = 1. / (1. + (dt - 1.)/alpha)**0.01 - 1. / (1. + dt/alpha)**0.01
result = log(structural * temporal)
return result
cdef DTYPE_t weight_failure(int dist, int dt, DTYPE_t alpha,
DTYPE_t delta, DTYPE_t gamma):
"""weight for failed infection, exponential time model"""
cdef DTYPE_t structural, temporal, result
structural = delta ** (dist)
temporal = 1. - exp(-alpha * dt)
#result = log(1. - structural)
result = log(1. - structural * temporal)
return result
cdef DTYPE_t weight_failure_power(int dist, int dt, DTYPE_t alpha,
DTYPE_t delta, DTYPE_t gamma):
"""weight for failed infection, power-law time model"""
cdef DTYPE_t structural, temporal, result
structural = delta ** (dist)
temporal = 1. - 1. / (1. + dt/alpha)**0.01
result = log(1. - structural * temporal)
return result
def ml(dict root_victims, dict victims, dict non_victims, DTYPE_t age,
DTYPE_t alpha, DTYPE_t delta, DTYPE_t gamma=10):
cdef:
int n_roots, n_victims, n_nodes, roots, i, dist, dt, t, l
DTYPE_t beta, ll, beta2
list parents, failures, successes
n_roots, n_victims = len(root_victims), len(victims)
n_nodes = n_roots + n_victims + len(non_victims)
cdef:
np.ndarray[DTYPE_t] probs = np.zeros(n_victims, dtype=DTYPE)
np.ndarray[DTYPE_t] probs_fail = np.zeros(n_victims, dtype=DTYPE)
np.ndarray[DTYPE_t] probs_nv = np.zeros(len(non_victims), dtype=DTYPE)
# loop through victims
for i, parents in enumerate(victims.itervalues()):
# for each victim node i, compute the probability that all its parents
# fail to infect it, also computes the probability that its most
# likely parent infects it
failures = [weight_failure(dist, dt, alpha, delta, gamma)
for (dist, dt, w1, w2, w3) in parents]
probs_fail[i] = sum(failures)
successes = [weight_success(dist, dt, alpha, delta, gamma)
for (dist, dt, w1, w2, w3) in parents]
# find parent that maximizes p/\tilde{p}
probs[i] = max(s - failures[l] for l, s in enumerate(successes))
# loop through non-victims
for i, parents in enumerate(non_victims.itervalues()):
# for each non victim node, compute the probability that all its
# parents fail to infect it
failures = [weight_failure(dist, dt, alpha, delta, gamma)
for (dist, dt, w1, w2, w3) in parents]
probs_nv[i] = sum(failures)
# calculate log likelihood
probs.sort(); probs = probs[::-1] # sort probs in descending order
cdef:
np.ndarray[DTYPE_t] cums = probs.cumsum()
ll = probs_fail.sum()
ll += probs_nv.sum()
for i in xrange(n_victims - 1, 0, -1):
# iterate over all victim nodes to find the optimal threshold
roots = n_roots + n_victims - 1 - i
beta = 1. / (1. + exp(-probs[i]))#exp(probs[i])#
if beta > float(roots) / age:
break
else:
print "alpha: {0}, delta: {1}. Everyone is a root".format(alpha, delta)
roots = n_victims + n_roots
i = -1
beta = float(roots) / age
for i in xrange(n_victims - 1, 0, -1):
if probs[i] >= log(beta/(1.- beta)):
break
ll += age * log(1 - beta)
if i >= 0:
ll += cums[i]
if roots > 0:
ll += roots * log(beta) - roots * log(1 - beta)
return (beta, roots, ll)
|
