亲和传播的收敛

Question

事实上，我想用亲和传播算法的结果来生成进化算法的初始种群，以解决社交网络中社区检测的问题。所以在算法的每次迭代中我都保留了结果，最后我有N个解，其中N是迭代次数。

蟒蛇代码如下：

def affinity_propagation3(S, preference=None, convergence_iter=25, max_iter=200, 
        damping=0.5, copy=True, verbose=False, 
        return_n_iter=False): 

S = as_float_array(S, copy=copy) 
n_samples = S.shape[0] 
L1=[] 

if S.shape[0] != S.shape[1]: 
    raise ValueError("S must be a square array (shape=%s)" % repr(S.shape)) 

if preference is None: 
    preference = np.median(S) 
if damping < 0.5 or damping >= 1: 
    raise ValueError('damping must be >= 0.5 and < 1') 

random_state = np.random.RandomState(0) 

# Place preference on the diagonal of S 
S.flat[::(n_samples + 1)] = preference 

A = np.zeros((n_samples, n_samples)) 
R = np.zeros((n_samples, n_samples)) # Initialize messages 
# Intermediate results 
tmp = np.zeros((n_samples, n_samples)) 

# Remove degeneracies 
S += ((np.finfo(np.double).eps * S + np.finfo(np.double).tiny * 100) * 
     random_state.randn(n_samples, n_samples)) 

# Execute parallel affinity propagation updates 
e = np.zeros((n_samples, convergence_iter)) 

ind = np.arange(n_samples) 

for it in range(max_iter): 
    # tmp = A + S; compute responsibilities 
    np.add(A, S, tmp) 
    I = np.argmax(tmp, axis=1) 
    Y = tmp[ind, I] # np.max(A + S, axis=1) 
    tmp[ind, I] = -np.inf 
    Y2 = np.max(tmp, axis=1) 

    # tmp = Rnew 
    np.subtract(S, Y[:, None], tmp) 
    tmp[ind, I] = S[ind, I] - Y2 

    # Damping 
    tmp *= 1 - damping 
    R *= damping 
    R += tmp 

    # tmp = Rp; compute availabilities 
    np.maximum(R, 0, tmp) 
    tmp.flat[::n_samples + 1] = R.flat[::n_samples + 1] 

    # tmp = -Anew 
    tmp -= np.sum(tmp, axis=0) 
    dA = np.diag(tmp).copy() 
    tmp.clip(0, np.inf, tmp) 
    tmp.flat[::n_samples + 1] = dA 

    # Damping 
    tmp *= 1 - damping 
    A *= damping 
    A -= tmp 

    # Check for convergence 
    E = (np.diag(A) + np.diag(R)) > 0 
    e[:, it % convergence_iter] = E 
    K = np.sum(E, axis=0) 

    if it >= convergence_iter: 
     se = np.sum(e, axis=1) 
     unconverged = (np.sum((se == convergence_iter) + (se == 0)) 
         != n_samples) 
     if (not unconverged and (K > 0)) or (it == max_iter): 
      if verbose: 
       print("Converged after %d iterations." % it) 
      break 
    print "iteration",it 
    I = np.where(np.diag(A + R) > 0)[0] 
    K = I.size # Identify exemplars 
    if K > 0: 
     c = np.argmax(S[:, I], axis=1) 
     c[I] = np.arange(K) # Identify clusters 
     for k in range(K): 
      ii = np.where(c == k)[0] 
      j = np.argmax(np.sum(S[ii[:, np.newaxis], ii], axis=0)) 
      I[k] = ii[j] 
     c = np.argmax(S[:, I], axis=1) 
     c[I] = np.arange(K) 
     labels = I[c] 
     cluster_centers_indices = np.unique(labels) 
     labels = np.searchsorted(cluster_centers_indices, labels) 
     L1.append(labels) 


if return_n_iter: 
    return cluster_centers_indices, labels, it + 1 
else: 
    return L1 

但我的问题是：几个迭代后的代码返回它们会降低种群的多样性同样的结果。 代码应用“海豚网” https://networkdata.ics.uci.edu/data.php?id=6

预先感谢您

Answer 1

是上，AP应该汇聚和融合是指它的变化越来越少。

不，这不是一个好的方法来为进化算法生成一个初始种群，因为它们确实必须被期望非常相似。