Esempio n. 1
0
def metrics(a,
            appVal,
            degenName="NoModel",
            pcLoss="0",
            edgePCCons = [v for v in range(1,11)],
            dVal = "2",
            thresholdtype = "local"
            ):
    appValW = appVal
    appValT = appVal


#    # prepare matrices for weighted measures
#    pcCent = mbt.np.zeros((len(a.G.nodes()), 10))
#    betCentT = mbt.np.zeros((len(a.G.nodes()), 10))
#    nM = mbt.np.zeros((10))
#    wmd = mbt.np.zeros((len(a.G.nodes()), 10))
    
    
#    pcCentNm = mbt.np.zeros((len(a.G.nodes()), 10))
#    nMNm = mbt.np.zeros((10))
#    wmdNm = mbt.np.zeros((len(a.G.nodes()), 10))    
#    QNm = mbt.np.zeros((10))

    # unweighted measures
    for n,e in enumerate(edgePCCons):
        ofb = '_'.join(["brain", degenName, thresholdtype, str(e), "d"+dVal+"_"])

        a.localThresholding(edgePC=e)
        
        a.makebctmat()
        a.weightToDistance()

        propDict = {"edgePC":str(a.edgePC),
                    "pcLoss":pcLoss}
        degs = a.G.degree(weight='weight')
        extras.writeResults(degs, "degreeWt", ofb, propDict=propDict,
                            append=appVal)

	# weighted betweenness centrality
#        bcT = mbt.centrality.betweenness_centrality(a.G, weight='distance')    
#        betCentT[:,n] = [bcT[v] for v in a.G.nodes()]

#        # weighted modularity metrics
#        ci = bct.modularity_louvain_und_sign(a.bctmat)
#        Q = ci[1]
#        ciN = a.assignbctResult(ci[0])
#        extras.writeResults(Q, "QWt", ofb, propDict=propDict, append=appValT)
#        extras.writeResults(ciN, "ciWt", ofb, propDict=propDict, append=appValT)  
#        
#        nMWt = len(mbt.np.unique(ci[0]))
#        nM[n] = nMWt
#        extras.writeResults(nMWt, "nMWt", ofb, propDict=propDict, append=appValT)
#        del(nMWt)
#    
#        wmdWt = extras.withinModuleDegree(a.G, ciN, weight='weight')
#        wmd[:,n] = [wmdWt[v] for v in a.G.nodes()]
#        extras.writeResults(wmdWt, "wmdWt", ofb, propDict=propDict, append=appValT)
#        del wmdWt
#        
#        pcCentWt = bct.participation_coef_sign(a.bctmat,ci[0])
#        pcCent[:,n] = pcCentWt
#        pcCentWt = a.assignbctResult(pcCentWt)
#        extras.writeResults(pcCentWt, "pcCentWt", ofb, propDict=propDict, append=appValT)
#        
#        # infomap partitioning
#        bIM = infomap.nx2infomap(a.G)
#        del(bIM)
#        try:
#            f = open("nxdigraph.clu", "r") # recapture results from output file
#            modules = mbt.np.array([int(v.strip('\n')) for v in f.readlines()[1:]])
#            f.close()
#            remove("nxdigraph.clu")
#    
#            ciNIM = a.assignbctResult(modules)
#            QIM = community.modularity(ciNIM, a.G)            
#            
#            pcCentIM = bct.participation_coef_sign(a.bctmat, modules)
#            pcCentIM = a.assignbctResult(pcCentIM)
#            wmdIM = extras.withinModuleDegree(a.G, ciNIM, weight='weight')
#            nMIM = len(np.unique(ciNIM[0]))
#        
#        except:
#            modules = np.array((np.repeat(np.nan, len(a.G.nodes()))))
#            QIM = "NA"
#            pcCentIM = {v:"NA" for v in a.G.nodes()}
#            wmdIM = {v:"NA" for v in a.G.nodes()}
#            ciNIM = {v:"NA" for v in a.G.nodes()}
#            nMIM = 0
#    
#        extras.writeResults(QIM, "QIM", ofbT, propDict=propDict, append=appValT)
#        extras.writeResults(ciNIM, "ciIM", ofbT, propDict=propDict, append=appValT)
#        del QIM
#        
#        extras.writeResults(nMIM, "nMIM", ofbT, propDict=propDict, append=appValT)
#        del nMIM
#        
#        extras.writeResults(pcCentIM, "pcCentIM", ofbT, propDict=propDict, append=appValT)
#        del pcCentIM
#    
#        extras.writeResults(wmdIM, "wmdIM", ofbT, propDict=propDict, append=appValT)
#        del(wmdIM, ciNIM)
#
#
#        # infomap partitioning
#        bIM = infomap.nx2infomap(a.G)
#        del(bIM)
#        f = open("nxdigraph.clu", "r") # recapture results from output file
#        modules = mbt.np.array([int(v.strip('\n')) for v in f.readlines()[1:]])
#        f.close()
#        remove("nxdigraph.clu")
#        
#        ciNIM = a.assignbctResult(modules)
#        QIMWt = community.modularity(ciNIM, a.G)
#        QIM[n] = QIMWt
#        extras.writeResults(QIMWt, "QIMWt", ofbT, propDict=propDict,append=appValT)
#        extras.writeResults(ciNIM, "ciIMWt", ofbT, propDict=propDict, append=appValT)
#        del(QIMWt)
#        
#        nMIMWt = len(np.unique(modules))
#        nMIM[n] = nMIMWt
#        extras.writeResults(nMIMWt, "nMIMWt", ofbT, propDict=propDict, append=appValT)
#        del(nMIMWt)
#        
#        pcCentIMWt = bct.participation_coef_sign(a.bctmat, modules)
#        pcCentIM[:,n] = pcCentIMWt
#        pcCentIMWt = a.assignbctResult(pcCentIMWt)
#        extras.writeResults(pcCentIMWt, "pcCentIMWt", ofbT, propDict=propDict, append=appValT)
#        del(pcCentIMWt)
#        
#        wmdIMWt = extras.withinModuleDegree(a.G, ciNIM, weight='weight')
#        wmdIM[:,n] = [wmdIMWt[v] for v in a.G.nodes()]
#        extras.writeResults(wmdIMWt, "wmdIMWt", ofbT, propDict=propDict, append=appValT)
#        del wmdIMWt


#        # Newman partitioning
#        ciNm = bct.modularity_und(a.bctmat)
#        QNmWt = ciNm[1]
#        QNm[n] = QNmWt
#        ciNNm = a.assignbctResult(ciNm[0])
#        extras.writeResults(QNmWt, "QNmWt", ofb, propDict=propDict, append=appValT)
#        extras.writeResults(ciNNm, "ciNmWt", ofb, propDict=propDict, append=appValT)  
#        
#        nMNmWt = len(mbt.np.unique(ciNm[0]))
#        nMNm[n] = nMNmWt
#        extras.writeResults(nMNmWt, "nMNmWt", ofb, propDict=propDict, append=appValT)
#        del(nMNmWt)
#    
#        pcCentNmWt = bct.participation_coef_sign(a.bctmat,ciNm[0])
#        pcCentNm[:,n] = pcCentNmWt
#        pcCentNmWt = a.assignbctResult(pcCentNmWt)
#        extras.writeResults(pcCentNmWt, "pcCentNmWt", ofb, propDict=propDict, append=appValT)
#        
#        wmdNmWt = extras.withinModuleDegree(a.G, ciNNm, weight='weight')
#        wmdNm[:,n] = [wmdNmWt[v] for v in a.G.nodes()]
#        extras.writeResults(wmdNmWt, "wmdNmWt", ofb, propDict=propDict, append=appValT)
#        del wmdNmWt

        appValT=True

	# now to collect measures in a binary graph
        a.binarise()

        a.weightToDistance()
        a.makebctmat()
        
        #### small worldness metrics ####
        degs = mbt.nx.degree(a.G)
        extras.writeResults(degs, "degree", ofb, propDict=propDict,
                            append=appVal)
        
#        clustCoeff = mbt.nx.average_clustering(a.G)
#        extras.writeResults(clustCoeff, "clusterCoeff", ofb, propDict=propDict,
#                            append=appVal)
#        del(clustCoeff)
#        
#        pl = mbt.nx.average_shortest_path_length(a.G)
#        extras.writeResults(pl, "pl", ofb, propDict=propDict, append=appVal)
#        del(pl)
#        
#        ge = extras.globalefficiency(a.G)
#        extras.writeResults(ge, "ge", ofb, propDict=propDict, append=appVal)
#        del(ge)
#        
#        le = extras.localefficiency(a.G)
#        extras.writeResults(le, "le", ofb, propDict=propDict, append=appVal)
#        del(le)
#    
#        # hub metrics
#        betCent = mbt.centrality.betweenness_centrality(a.G)
#        extras.writeResults(betCent, "betCent", ofb, propDict=propDict,
#                            append=appVal)
#        
#        closeCent = mbt.centrality.closeness_centrality(a.G)
#        extras.writeResults(closeCent, "closeCent", ofb, propDict=propDict,
#                            append=appVal)
#         
#        hs = extras.hubscore(a.G, bc=betCent, cc=closeCent, degs=degs,
#                             weighted=False)
#        extras.writeResults(hs, "hs", ofb, propDict=propDict, append=appVal)
#        del(hs, betCent, closeCent, degs)
#         
#        try:
#            eigCent = mbt.centrality.eigenvector_centrality_numpy(a.G)
#        except:
#            eigCent = dict(zip(a.G.nodes(), ['NA' for n in a.G.nodes()]))
#        extras.writeResults(eigCent, "eigCentNP", ofb, propDict=propDict,
#                            append=appVal)
#        del(eigCent)
#        
#        eln = extras.edgeLengths(a.G, nodeWise=True)
#        extras.writeResults(eln, "eln", ofb, propDict=propDict, append=appVal)
#        del(eln)
#        
#        el = extras.edgeLengths(a.G)
#        meanEL = mbt.np.mean(mbt.np.array((el.values()), dtype=float))
#        extras.writeResults(meanEL, "meanEL", ofb, propDict=propDict,
#                            append=appVal)
#    
#        medianEL = mbt.np.median(mbt.np.array((el.values()), dtype=float))
#        extras.writeResults(medianEL, "medianEL", ofb, propDict=propDict,
#                            append=appVal)
#    
#        del(el, meanEL, medianEL)
        
#        # modularity metrics
#        ci = bct.modularity_louvain_und(a.bctmat)
#        Q = ci[1]
#        ciN = a.assignbctResult(ci[0])
#        extras.writeResults(Q, "Q", ofb, propDict=propDict, append=appVal)
#        extras.writeResults(ciN, "ci", ofb , propDict=propDict, append=appVal)  
#        
#        pcCent = bct.participation_coef(a.bctmat,ci[0])
#        pcCent = a.assignbctResult(pcCent)
#        extras.writeResults(pcCent, "pcCent", ofb, propDict=propDict,
#                            append=appVal)
#        del pcCent
#        
#        wmd = extras.withinModuleDegree(a.G, ciN)
#        extras.writeResults(wmd, "wmd", ofb, propDict=propDict, append=appVal)
#        del wmd    
#        
#        nM = len(mbt.np.unique(ci[0]))
#        extras.writeResults(nM, "nM", ofb, propDict=propDict, append=appVal)
#        del(nM)
#        del(ci, ciN, Q)
#        
#        # rich club measures
#        rc = mbt.nx.rich_club_coefficient(a.G, normalized=False)
#        extras.writeResults(rc, "rcCoeff", ofb, propDict=propDict, append=appVal)
#        del(rc)
#        # robustness
#        rbt = a.robustness()
#        extras.writeResults(rbt, "robustness", ofb, propDict=propDict,
#                            append=appVal)
#
#        # infomap partitioning
#        bIM = infomap.nx2infomap(a.G)
#        del(bIM)
#        try:
#            f = open("nxdigraph.clu", "r") # recapture results from output file
#            modules = mbt.np.array([int(v.strip('\n')) for v in f.readlines()[1:]])
#            f.close()
#            remove("nxdigraph.clu")
#    
#            ciNIM = a.assignbctResult(modules)
#            QIM = community.modularity(ciNIM, a.G)            
#            
#            pcCentIM = bct.participation_coef_sign(a.bctmat, modules)
#            pcCentIM = a.assignbctResult(pcCentIM)
#            wmdIM = extras.withinModuleDegree(a.G, ciNIM, weight='weight')
#            nMIM = len(np.unique(ciNIM[0]))
#        
#        except:
#            modules = np.array((np.repeat(np.nan, len(a.G.nodes()))))
#            QIM = "NA"
#            pcCentIM = {v:"NA" for v in a.G.nodes()}
#            wmdIM = {v:"NA" for v in a.G.nodes()}
#            ciNIM = {v:"NA" for v in a.G.nodes()}
#            nMIM = 0
#        
#        extras.writeResults(QIM, "QIM", ofbT, propDict=propDict, append=appValT)
#        extras.writeResults(ciNIM, "ciIM", ofbT, propDict=propDict, append=appValT)
#        del QIM
#        
#        extras.writeResults(nMIM, "nMIM", ofbT, propDict=propDict, append=appValT)
#        del nMIM
#        
#        extras.writeResults(pcCentIM, "pcCentIM", ofbT, propDict=propDict, append=appValT)
#        del pcCentIM
#    
#        extras.writeResults(wmdIM, "wmdIM", ofbT, propDict=propDict, append=appValT)
#        del(wmdIM, ciNIM)
#
#        # Newman partitioning
#        ciNm = bct.modularity_und(a.bctmat)
#        QNm= ciNm[1]
#        ciNNm = a.assignbctResult(ciNm[0])
#        extras.writeResults(QNm, "QNm", ofb, propDict=propDict, append=appValT)
#        extras.writeResults(ciNNm, "ciNm", ofb, propDict=propDict, append=appValT)
#        del QNm
#        
#        nMNm = len(mbt.np.unique(ciNm[0]))
#        extras.writeResults(nMNm, "nMNm", ofb, propDict=propDict, append=appValT)
#        del nMNm
#    
#        pcCentNm = bct.participation_coef_sign(a.bctmat,ciNm[0])
#        pcCentNm = a.assignbctResult(pcCentNm)
#        extras.writeResults(pcCentNm, "pcCentNm", ofb, propDict=propDict, append=appValT)
#        del pcCentNm
#        
#        wmdNm = extras.withinModuleDegree(a.G, ciNNm, weight='weight')
#        extras.writeResults(wmdNm, "wmdNm", ofb, propDict=propDict, append=appValT)
#        del(wmdNm,ciNNm,ciNm)

        # append any further iterations
        appVal = True
    
#    propDict = {"pcLoss":pcLoss}
#    # weighted measures
#    a.adjMatThresholding(MST=False)
#    a.weightToDistance()
#    ofb = '_'.join(["brain", degenName, "d"+dVal+"_"])
#    a.makebctmat()
#    
#    # weighted hub metrics
#    degs = a.G.degree(weight='weight')
#    extras.writeResults(degs, "degree_wt", ofb, propDict=propDict, append=appValW)
#    
#    betCent = mbt.centrality.betweenness_centrality(a.G, weight='distance')
#    extras.writeResults(betCent, "betCent_wt", ofb, propDict=propDict, append=appValW)
#    
#    closeCent = mbt.centrality.closeness_centrality(a.G, distance='distance')
#    extras.writeResults(closeCent, "closeCent_wt", ofb, propDict=propDict, append=appValW)
#    
#    eigCent = mbt.centrality.eigenvector_centrality_numpy(a.G)
#    extras.writeResults(eigCent, "eigCentNP_wt", ofb, propDict=propDict, append=appValW)
#    del(eigCent)
    
#    # weighted modularity metrics
#    ci = bct.modularity_louvain_und_sign(a.bctmat)
#    Q = ci[1]
#    ciN = a.assignbctResult(ci[0])
#    extras.writeResults(Q, "Q_wt", ofb, propDict=propDict, append=appValW)
#    extras.writeResults(ciN, "ci_wt", ofb, propDict=propDict, append=appValW)  
#    
#    nM = len(mbt.np.unique(ci[0]))
#    extras.writeResults(nM, "nM_wt", ofb, propDict=propDict, append=appValW)
#    del(nM)
#    
#    wmd = extras.withinModuleDegree(a.G, ciN, weight='weight')
#    extras.writeResults(wmd, "wmd_wt", ofb, propDict=propDict, append=appValW)
#    del wmd
#        
    appValT=False
        
#    pcCent = a.assignbctResult(mbt.np.mean(pcCent, axis=1))
#    extras.writeResults(pcCent, "pcCentWt_wt", ofb, propDict=propDict, append=appValW)
#    del(pcCent,ci)
#    
#    betCentT = a.assignbctResult(mbt.np.mean(betCentT, axis=1))
#    extras.writeResults(betCentT, "betCentWtT_wt", ofb, propDict=propDict, append=appValW)
#    
#    nM = mbt.np.mean(nM)
#    extras.writeResults(nM, "nMWt_wt", ofb, propDict=propDict, append=appValW)
#    del(nM)
#    
#    wmd = a.assignbctResult(mbt.np.mean(wmd, axis=1))
#    extras.writeResults(wmd, "wmdWt_wt", ofb, propDict=propDict, append=appValW)
#    del(wmd)
#    
#
#    # Infomap
#    QIM = np.mean(QIM)
#    extras.writeResults(QIM, "QIMWt_wt", ofb, append=appVal)
#    del(QIM)
#    
#    pcCentIM = a.assignbctResult(np.mean(pcCentIM, axis=1))
#    extras.writeResults(pcCentIM, "pcCentIMWt_wt", ofb, append=appVal)
#    del(pcCentIM)
#     
#    wmdIM = a.assignbctResult(np.mean(wmdIM, axis=1))
#    extras.writeResults(wmdIM, "wmdIMWt_wt", ofb, append=appVal)
#    del(wmdIM)
#    
#    nMIM = np.mean(nMIM)
#    extras.writeResults(nMIM, "nMIMWt_wt", ofb, append=appVal)
#    del(nMIM)
#
#    # Newman
#    QNm = mbt.np.mean(QNm)
#    extras.writeResults(QNm, "QNmWt_wt", ofb, append=appValW)
#    del(QNm)
#    
#    pcCentNm = a.assignbctResult(mbt.np.mean(pcCentNm, axis=1))
#    extras.writeResults(pcCentNm, "pcCentNmWt_wt", ofb, append=appValW)
#    del(pcCentNm)
#     
#    wmdNm = a.assignbctResult(mbt.np.mean(wmdNm, axis=1))
#    extras.writeResults(wmdNm, "wmdNmWt_wt", ofb, append=appValW)
#    del(wmdNm)
#    
#    nMNm = mbt.np.mean(nMNm)
#    extras.writeResults(nMNm, "nMNmWt_wt", ofb, append=appValW)
#    del(nMNm)
    a.applyThreshold()
Esempio n. 2
0
a = mbt.brainObj()
appVal = False
appValT = False

# unweighted measures
# iterate through thresholds
for e in edgePCCons:
    ofb = '_'.join(["brain", thresholdtype, str(e), "d"+dVal+"_"])
    propDict = {"edgePC":str(e)} # added properties for results files

    a.importAdjFile(adjMatFile, delimiter=delim)
    a.localThresholding(edgePC=e)  # apply a threshold
    a.removeUnconnectedNodes()     # remove unconnected nodes
    
    degs = a.G.degree(weight='weight')
    extras.writeResults(degs, "degreeWt", ofb, append=appVal)

    a.binarise()  # binarise the graph
    a.importSpatialInfo(parcelFile)  # read spatial information
    a.weightToDistance() # convert weights to distance (for closeness centrality function)
    a.makebctmat() # create an array to be used by the brain connectivity toolbox functions
    
    ofbT = '_'.join(["brain", thresholdtype, str(e), "d"+dVal+"_"])  
   
    #### small worldness metrics ####
    degs = mbt.nx.degree(a.G)  # measure degree
    extras.writeResults(degs, "degree", ofb, propDict=propDict, append=appVal)  # write the results to a file
        
    clustCoeff = mbt.nx.average_clustering(a.G)
    extras.writeResults(clustCoeff, "clusterCoeff", ofb, propDict=propDict, append=appVal)
    del(clustCoeff)