Exemple #1
0
def partitioning(G, k):
    A = nx.adjacency_matrix(G)

    # Alpah cut
    M = Handler.alphaCut(A, 1)

    # eigen calculation
    eigenvalues, eigenvectors = np.linalg.eig(M)
    # define K
    partitionSize = k
    # tempEigenValues = np.absolute(eigenvalues)
    tempEigenValues = eigenvalues

    idx = tempEigenValues.argsort()[:partitionSize][::]
    eigenValues = tempEigenValues[idx]
    eigenVectors = eigenvectors[:, idx]

    z = eigenVectors
    # normalize the matrix
    for i in range(0, eigenVectors.shape[0]):
        total = 0
        for j in range(0, eigenVectors.shape[1]):
            total += abs(eigenVectors.item((i, j)))**2
        if (total > 0):
            z[i] = z[i] / (total**(1 / 2))
    # z = np.matrix.transpose(z)
    # find k means paritions
    kmeans = KMeans(n_clusters=partitionSize, random_state=0).fit(z)

    lables = kmeans.labels_

    array = Handler.indexArray(G.nodes(), partitionSize, lables)
    np.savetxt('test_1.txt', array, fmt='%r')
    print(lables)
    # New partition array
    partitionArray = []
    # get each laplacian matrix
    for k in array:

        # sort = tempEigenvalues
        if (len(k) > 1):
            print(k)
            H = G.subgraph(k)
            r = nx.connected_components(H)
            for i in r:
                partitionArray.append(i)
        else:
            partitionArray.append(k)

    matrix, edgecut1 = Handler.conectivityMatrix(partitionArray, G)
    print(edgecut1)
    edgecut2 = 0
    q = queue.Queue()
    partitionQueue = queue.Queue()
    partitionQueue.put(partitionArray)
    q.put(matrix)
    alpha = Handler.alphaCut(matrix, 0)
    partitionCount = 1
    part = []
    part.append(partitionArray)
    while (partitionCount != partitionSize):
        if (q.empty() is False):
            matrix = q.get()
            if (matrix.shape[0] > 1):
                alpha = Handler.alphaCut(matrix, 0)

                eigenvalues, eigenvectors = np.linalg.eig(alpha)

                tempEigenValues = np.absolute(eigenvalues)
                idx = tempEigenValues.argsort()[:2][::]
                eigenValues = tempEigenValues[idx]
                eigenVectors = eigenvectors[:, idx]

                z = eigenVectors

                # normalize the matrix
                for i in range(0, eigenVectors.shape[0]):
                    total = 0
                    for j in range(0, eigenVectors.shape[1]):
                        total += abs(eigenVectors.item((i, j)))**2
                    if (total > 0):
                        z[i] = z[i] / (total**(1 / 2))
                # norm = np.linalg.norm(z,axis=1,ord=2)
                # print(norm)
                # z = z.astype(np.float)/norm[:,None]
                # print(z)
                # find k means paritions
                kmeans = KMeans(n_clusters=2, random_state=0).fit(z)
                w = 0
                p1, p2 = [], []
                partition = partitionQueue.get()
                for p in kmeans.labels_:
                    if (p == 0):
                        p1.append(partition[w])
                    else:
                        p2.append(partition[w])
                    w += 1
                put1, tempedge1 = Handler.conectivityMatrix(p1, G)
                put2, tempedge2 = Handler.conectivityMatrix(p2, G)
                edgecut2 += tempedge1 + tempedge2
                part.pop(0)
                if (len(p1) >= len(p2)):
                    partitionQueue.put(p2)
                    partitionQueue.put(p1)

                    q.put(put2)
                    q.put(put1)

                    part.append(p2)
                    part.append(p1)
                else:
                    partitionQueue.put(p1)
                    partitionQueue.put(p2)

                    q.put(put1)
                    q.put(put2)

                    part.append(p1)
                    part.append(p2)

        partitionCount += 1

    partition = []
    for p in part:
        partTemp = []
        for par in p:
            for part in par:
                partTemp.append(part)
        partition.append(partTemp)
    return partition
Exemple #2
0
        if 0 in tempEigenvectors:
            counter=collections.Counter(sort)
            p = list(counter.values())[-1]
            kmeans = KMeans(n_clusters=p+1, random_state=0).fit(tempEigenvectors[:,[list(tempEigenvalues).index(0)]])
            lables = kmeans.labels_
            arrays = Handler.indexArray(k,p+1,lables)
            for i in arrays:
                partitionArray.append(i)
        else:
            partitionArray.append(k)
    else:
        partitionArray.append(k)



matrix = Handler.conectivityMatrix(partitionArray,G)
q = queue.Queue()
partitionQueue = queue.Queue();
partitionQueue.put(partitionArray);
q.put(matrix)
alpha = Handler.alphaCut(matrix,0)
partitionCount = 1
part =[]
part.append(partitionArray)
while(partitionCount!=partitionSize):
    if(q.empty() is False):
        matrix = q.get()
        if(matrix.shape[0]>1):
            alpha = Handler.alphaCut(matrix,0)

            eigenvalues, eigenvectors = np.linalg.eig(alpha)
Exemple #3
0
    if (sort.size > 2):
        if 0 in tempEigenvectors:
            counter = collections.Counter(sort)
            p = list(counter.values())[-1]
            kmeans = KMeans(n_clusters=p + 1, random_state=0).fit(
                tempEigenvectors[:, [list(tempEigenvalues).index(0)]])
            lables = kmeans.labels_
            arrays = Handler.indexArray(k, p + 1, lables)
            for i in arrays:
                partitionArray.append(i)
        else:
            partitionArray.append(k)
    else:
        partitionArray.append(k)

matrix, edgecut1 = Handler.conectivityMatrix(partitionArray, G)
edgecut2 = 0
q = queue.Queue()
partitionQueue = queue.Queue()
partitionQueue.put(partitionArray)
q.put(matrix)
alpha = Handler.alphaCut(matrix, 0)
partitionCount = 1
part = []
part.append(partitionArray)
while (partitionCount != partitionSize):
    if (q.empty() is False):
        matrix = q.get()
        if (matrix.shape[0] > 1):
            alpha = Handler.alphaCut(matrix, 0)
        if (0 in tempEigenvectors) & (p > 1):
            index = []
            for t in range(0, len(tempEigenvalues)):
                if (tempEigenvalues[t] == 0):
                    index.append(t)
            kmeans = KMeans(n_clusters=p, random_state=0).fit(tempEigenvectors[:, index])
            lables = kmeans.labels_
            arrays = Handler.indexArray(k, p, lables)
            for i in arrays:
                partitionArray.append(i)
        else:
            partitionArray.append(k)
    else:
        partitionArray.append(k)
np.savetxt('test_colombo.txt', partitionArray,fmt='%r')
matrix,edgecut1 = Handler.conectivityMatrix(partitionArray,G)
edgecut2 = 0
put,edgeConectivity = Handler.conectivityMatrix(partitionArray,G)
alpha = Handler.alphaCut(matrix,0)
partitionCount = 1
part =[]
part.append(partitionArray)
while(len(part)!=partitionSize):
    if(len(part)>0):
        max , id = 0,0
        for i in range(0,len(part)):
            if len(part[i])>max:
                max = len(part[i])
                id = i
        matrix, edgeCount = Handler.conectivityMatrix(part[id], G)
        partition = part[id]
with open("test_5.txt") as f:
    datas = f.read()
# print(data.split(']')[0])
partitionArray = []
for k in range(0, 238):
    partition_data = datas.split('\n')[k].replace('{',
                                                  '').replace('}',
                                                              '').split(', ')

    tempartition = []
    for i in partition_data:
        tempartition.append(int(i))

    partitionArray.append(tempartition)

adjecencyMatrix, edgecut = Handler.conectivityMatrix(partitionArray, G, data)
# sort the partition array
sorter = []
for e in partitionArray:
    sorter.append(len(e))
sorter = np.asarray(sorter)
idSorter = sorter.argsort()[::-1][:]
tempPartitionArray = np.asarray(partitionArray)
tempPartitionArray = tempPartitionArray[idSorter]
partitionArray = []
for a in tempPartitionArray:
    partitionArray.append(a)
tempPartitionArray = partitionArray.copy()

dict = dict()
for i in range(0, partitionSize):