def opt_fn(work_par):
     work_par = work_par[0]
     if method in ('ilfrs', 'ilfr'):
         partition = community_ext.best_partition(G,
                                                  model=method,
                                                  pars={'mu': work_par})
         loglike = community_ext.model_log_likelihood(G,
                                                      partition,
                                                      model=method,
                                                      pars={'mu': work_par})
     else:
         partition = community_ext.best_partition(G,
                                                  model=method,
                                                  pars={'gamma': work_par})
         loglike = community_ext.model_log_likelihood(
             G, partition, model=method, pars={'gamma': work_par})
     return -loglike
def opt_par(G, method, par):
    def opt_fn(work_par):
        work_par = work_par[0]
        if method in ('ilfrs', 'ilfr'):
            partition = community_ext.best_partition(G,
                                                     model=method,
                                                     pars={'mu': work_par})
            loglike = community_ext.model_log_likelihood(G,
                                                         partition,
                                                         model=method,
                                                         pars={'mu': work_par})
        else:
            partition = community_ext.best_partition(G,
                                                     model=method,
                                                     pars={'gamma': work_par})
            loglike = community_ext.model_log_likelihood(
                G, partition, model=method, pars={'gamma': work_par})
        return -loglike

    # find the optimal parameter value
    best_par = float(
        scipy.optimize.fmin_powell(opt_fn, par, full_output=False, disp=False))

    # calculate the partition with the optimal parameter value
    if method in ('ilfrs', 'ilfr'):
        partition = community_ext.best_partition(G,
                                                 model=method,
                                                 pars={'mu': best_par})
        loglike = community_ext.model_log_likelihood(G,
                                                     partition,
                                                     model=method,
                                                     pars={'mu': best_par})
    else:
        partition = community_ext.best_partition(G,
                                                 model=method,
                                                 pars={'gamma': best_par})
        loglike = community_ext.model_log_likelihood(G,
                                                     partition,
                                                     model=method,
                                                     pars={'gamma': best_par})
    return partition, loglike, best_par
Exemple #3
0
    prev_par, it = -1, 0
    prev_pars = set()
    while abs(work_par -
              prev_par) > 1e-5:  # stop if the size of improvement too small
        it += 1
        if it > 100: break  # stop after 100th iteration

        # update the parameter value
        prev_par = work_par
        if prev_par in prev_pars: break  # stop if we are in the cycle
        prev_pars.add(prev_par)

        # find the optimal partition with the current parameter value
        if method in ('ilfrs', ):
            partition = community_ext.best_partition(G,
                                                     model=method,
                                                     pars={'mu': work_par})
        else:
            partition = community_ext.best_partition(G,
                                                     model=method,
                                                     pars={'gamma': work_par})

        # calculate optimal parameter value for the current partition
        if method in ('ilfrs', ):
            work_par = community_ext.estimate_mu(G, partition)
        else:
            work_par = community_ext.estimate_gamma(G, partition, model=method)
        loglike = community_ext.model_log_likelihood(G,
                                                     partition,
                                                     model=method,
                                                     pars={