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
                                                     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={
                                                         'gamma': work_par,
                                                         'mu': work_par
                                                     })
        print('current par', work_par, 'loglike', loglike)

    # calculate and print the scores of resulting partition
    part_scores = community_ext.compare_partitions(groundtruth_partition,
                                                   partition)
    loglike = community_ext.model_log_likelihood(G,
                                                 partition,
                                                 model=method,
                                                 pars={
                                                     'gamma': work_par,
                                                     'mu': work_par
                                                 })