Ejemplo n.º 1
0
def glouton(k, graph, verbose, log):
    if log:
        print "Starting basic Glouton.."
        startTime = time.time()
    # initialisation
    initGraph = graph.copy()
    niList = []
    markingList = [] 
    potentialNodesList = []
    partitionList = []
    # initialisation du sommet de départ
    s0 = nodeWithLessNeighbor(graph, markingList)
    markingList.append(s0)
    potentialNodesList = setPotentialNodesList(graph,s0, markingList, potentialNodesList)    
    if verbose :
        print "Sommet de depart :", s0    
        print "Potential Nodes : ", potentialNodesList
    # initialisation de i : numéro de partition courante
    i = 1
    while i < k:
        # Calcul de ni : nombre de sommets pour la prochaine partition
        niList = calculateSizeListSubGraph(k, i, niList, initGraph)
        ni = niList[i-1]
        # j : nombre de sommets actuellement dans la partition courante
        j=1 	# on compte le sommet de départ
        while potentialNodesList != [] and j < ni:
            m = potentialNodesList[-1][0]
            markingList.append(m)
            potentialNodesList = setPotentialNodesList(graph,m, markingList, potentialNodesList)
            j = j+1
        # Affectation de la partition créée à la liste de partitions
        partitionList.append(markingList)
        # Réinitialisation des structures
        # Restructuration du graphe : suppression des sommets marqués
        graph.remove_nodes_from(markingList)
        markingList = [] 
        potentialNodesList = []
        i = i+1
        # Initialisation de la prochaine partition
        if i != k :
            s0 = nodeWithLessNeighbor(graph, markingList)
            markingList.append(s0)
            potentialNodesList = setPotentialNodesList(graph,s0, markingList, potentialNodesList)
    # partitionList ← sommets restants 
    partitionList.append(graph.nodes())
    graph = initGraph
    # probleme : si on ne return pas le graphe, ici il est bien égal
    # à tout le graphe mais sans le return il vaut une partition...
    
    stopTime = time.time()
    if verbose:
        print "Partition finale 1:", partitionList[0]
        print "Partition finale 2:", partitionList[1]
    if log:
        print "Optimum trouve:", objf.calculateCut(partitionList[0],partitionList[1],graph)
        print "Execution Time :", stopTime-startTime    
    
    return partitionList, graph
def calculateFictifGain(s1,s2,P1,P2,graph):
    # échange des sommets s1 et s2
    newP1 = list(P1)
    newP1.remove(s1)
    newP1.append(s2)
    newP2 = list(P2)
    newP2.remove(s2)
    newP2.append(s1)
    # newG : gain si on permute s1 et s2
    newG = objf.calculateCut(newP1, newP2, graph)
    #newG = objf.calculateGainNodesAB(s1, s2, newP1, newP2, graph)
    return newG
def calculateFictifGainUnique(s,P1,P2,graph):
    # déplacement du sommet s de P1 vers P2
    newP1 = list(P1)
    newP2 = list(P2)
    if s in newP1:
        newP1.remove(s)
        newP2.append(s)
    else :
        newP2.remove(s)
        newP1.append(s)
    # newG : gain si on déplace s de P1 vers P2
    newG = objf.calculateCut(newP1, newP2, graph)
    return newG
def kl(graph,verbose):
    print "Starting KL version 2.."
    startTime = time.time()
    ## Initialisation ##
    # Liste de partitions
    partitionsList = []
    # Initialisation des listes de sommets à étudier 
    # (une par partition)
    remainingNodesS1 = []
    remainingNodesS2 = []    
    
    ## Déroulement de l'algo ##    
    # bipartition
    partitionsList, graph = g.gloutonWithCut(2,graph,False,False)
    if verbose:
        print "Partition Init 1: ", partitionsList[0]
        print "Partition Init 2: ", partitionsList[1]

    deltaTime = -time.time()
    
    ratio = 20    
    
    # Mise a jour des listes des sommets à étudier
    remainingNodesS1 = list(partitionsList[0])[len(partitionsList[0])*(100-ratio)/100:]
    remainingNodesS2 = list(partitionsList[1])[len(partitionsList[1])*(100-ratio)/100:]

    # calcul du gain global initial
    globalMin = objf.calculateCut(remainingNodesS1,remainingNodesS2,graph)
    #  Initialisation du gain fictif
    GainGlobalFictif = globalMin
    if verbose:
        print "Global Min Initial:", globalMin
        print ""
        print "Recherche de sommets uniques à changer..."   
   
    nodesList = nx.nodes(graph)
    iterations = 100
    while iterations > 0 :
        improvement = False
        localMin = sys.maxint
        
        for node in nodesList:
            gain = calculateFictifGainUnique(node, partitionsList[0], partitionsList[1], graph)
            
            # recherche du meilleur gain local            
            if gain < localMin  and gain > 0 :
                improvement = True
                localMin = gain
                s = node
                GainGlobalFictif = globalMin - gain
                if verbose:
                    print "Nouveau gain local:", localMin, "Node: ", node
                    print "Gain Global Fictif =", GainGlobalFictif

        if improvement :
            nodesList.remove(s)        
        if (GainGlobalFictif < globalMin):
            globalMin = GainGlobalFictif
            if verbose:
                print "Nouveau gain global:", globalMin, "Node:", s
                print "Le noeud",s,"a été échangé de partition"
            partitionsList = switchNodesUnique(partitionsList,s)
        
        iterations = iterations - 1
 
    stopTime = time.time()
    deltaTime += time.time()
    print "Temps d'exécution total:", stopTime-startTime
    print "Temps d'exécution KL:", deltaTime
    if verbose:
        print "Partition Finale 1:", partitionsList[0]
        print "Partition Finale 2:", partitionsList[1]
    print "Global cut:", objf.calculateCut(partitionsList[0], partitionsList[1], graph)
def kl(graph,verbose):
    print "Starting KL version 3.."
    startTime = time.time()
    ## Initialisation ##

    # Sert à mémoriser les sommets échangés
    exchangedNodes = []
    # Liste de partitions
    partitionsList = []
    # Initialisation des listes de sommets à étudier 
    # (une par partition)
    remainingNodesS1 = []
    remainingNodesS2 = []
    
    #  Initialisation des listes de gain fictif
    GFictif = 0
    
    
    ## Déroulement de l'algo ##    
    # bipartition
    partitionsList, graph = g.glouton(2,graph,False,False)
    
    # Mise a jour des listes des sommets à étudier
    remainingNodesS1 = list(partitionsList[0])
    remainingNodesS2 = list(partitionsList[1])
    if verbose: 
        print "Partition Init 1: ", remainingNodesS1
        print "Partition Init 2: ", remainingNodesS2
    
    optimumEqu = False
    # boucle principale
    deltaTime = -time.time()
    
    # calcul du gain global initial
    globalMin = objf.calculateCut(remainingNodesS1,remainingNodesS2,graph)
    if verbose: 
        print "Global Min Initial:", globalMin

    while remainingNodesS1 != [] and remainingNodesS2 != [] and not optimumEqu:
        improvement = False
        P1 = list(partitionsList[0])
        P2 = list(partitionsList[1])
    
        localMin = sys.maxint

        # On inverse l'ordre de P1 et de P2 car les derniers sommets ajoutés
        # sont les plus susceptibles à ressortir en premier
        for nodeA in reversed(remainingNodesS1):
            # s1 : sommet candidat de S1 pour un échange
            s1 = nodeA

            for nodeB in reversed(remainingNodesS2):
                # on cherche le meilleur candidat pour un échange avec s1
                # Calcul du gain lié à l'échange de a et b : G(a,b)
                #gainAB = calculateFictifGain(s1, nodeB, P1, P2, graph)
                gainAB = objf.calculateGainNodesAB(s1, nodeB, P1, P2, graph)

                if gainAB + globalMin < localMin:
                    localMin = gainAB + globalMin
                    # s2 : sommet candidat de S2 pour un échange avec s1
                    s2 = nodeB
                    if verbose: 
                        print "Nouveau gain local:", localMin, "Nodes: ", s1, s2
                    #GFictif = gainAB
                    GFictif = localMin
                
                    
            # Mise a jour du gain global
            if (GFictif < globalMin):
                improvement = True
                globalMin = GFictif
                if verbose: 
                    print "Nouveau gain global:", globalMin, "Nodes:", s1, s2
                exchangedNodes.append(s1)
                exchangedNodes.append(s2)
                
                # P ← échanger les sommets s1 et s2
                partitionsList = switchNodes(partitionsList,s1,s2)                
                if verbose: 
                    print "Les noeuds",s1,"et",s2, "ont été échangés"                
                    print "Partition 1:", partitionsList[0]
                    print "Partition 2:", partitionsList[1]
                
                # Mise a jour des listes des sommets à étudier
                remainingNodesS1 = setRemainingNodes(partitionsList[0],exchangedNodes)
                remainingNodesS2 = setRemainingNodes(partitionsList[1],exchangedNodes)

  
        if (improvement == False):
            if verbose: 
                print "Optimum équilibré trouvé:", objf.calculateCut(partitionsList[0], partitionsList[1], graph)
            optimumEqu = True

    if verbose:
        print ""
        print "Recherche de sommets uniques à changer..."   
   
    while exchangedNodes != [] :
        localMin = sys.maxint
        
        for node in exchangedNodes:
            gain = calculateFictifGainUnique(node, partitionsList[0], partitionsList[1], graph)

            # recherche du meilleur gain local            
            if gain < localMin:
                localMin = gain
                if verbose:
                    print "Nouveau gain local:", localMin, "Node: ", node
                s = node
                GFictif = gain

        exchangedNodes.remove(s)        
        if (GFictif < globalMin):
            globalMin = GFictif
            if verbose: 
                print "Nouveau gain global:", globalMin, "Node:", s
                print "Le noeud",s,"a été échangé de partition"
            partitionsList = switchNodesUnique(partitionsList,s)
 
    stopTime = time.time()
    deltaTime += time.time()
    print "Temps d'exécution total:", stopTime-startTime
    print "Temps d'exécution KL:", deltaTime
    if verbose:
        print "Partition Finale 1:", partitionsList[0]
        print "Partition Finale 2:", partitionsList[1]
    print "Global cut:", objf.calculateCut(partitionsList[0], partitionsList[1], graph)     
Ejemplo n.º 6
0
def recuitSimule(graph, iterations, tempI, remonteeMax,verbose):
    print "Starting Recuit Simule with", iterations, "iterations,", tempI, "as initial temperature and", remonteeMax, "as max upgoing movements"

    deltaTime0 = -time.time()    
    
    ## Initialisation ##
    # Liste de partitions
    partitionsList = [] 
    
    # Appel du Glouton
    partitionsList, graph = g.gloutonWithCut(2,graph,False,False)
    P1Final = list(partitionsList[0])
    P2Final = list(partitionsList[1])
    if verbose :
        print "Partition P1 init :", P1Final
        print "Partition P2 init :", P2Final

    print "Number of nodes in graph:", nx.number_of_nodes(graph)
    # calcul du gain global initial
    globalMin = objf.calculateCut(partitionsList[0],partitionsList[1],graph)
    
    #  Initialisation du gain fictif
    GainGlobalFictif = globalMin
    print "Global Min Initial:", globalMin

    # Temps de départ
    deltaTime = -time.time()
    
    # Nombre d'iteration de l'algorithme
    iterationsC = 0

    # Nombre courant de remontée de temperature consecutives
    remontee = 0
    
    # Temperature courante
    tempC = tempI
    
    list_pourcentage = [0,10,20,30,40,50,60,70,80,90]
    
    nodesOnLimit,neighborsList = neighbors(partitionsList[0],graph)
    
    # Boucle principale
    while iterationsC < iterations :
        pourcentage = (iterationsC*100)/iterations
        if pourcentage in list_pourcentage:
            del(list_pourcentage[0])
            print '------------------',pourcentage, "% effectués", '------------------'            
            
        change = False

        # Candidat aleatoire de la partition P1
        nodeA = selectNode(nodesOnLimit)
        # Candidat aleatoire de la partition P2
        nodeB = selectNode(neighborsList)

        # Calcul du gain lié à l'échange de nodeA et nodeB : G(nodeA,nodeB)
        gainAB = calculateFictifGain(nodeA, nodeB, partitionsList[0], partitionsList[1], graph)
        
        if verbose:
            print "Gain entre",nodeA,"et",nodeB,"=",gainAB
        # Amelioration solution locale
        if gainAB >= 0 :
            change = True
            remontee = 0
            if verbose :
                print "Descente en temperature avec les noeuds", nodeA, "et", nodeB                
                
        else:
            # Acceptation de la solution dégradante 
            if random() < exp(gainAB/tempC) and remontee < remonteeMax :
                change = True
                remontee +=1
                if verbose :
                    print "Remontee en temperature avec les noeuds", nodeA, "et", nodeB                

        # Changement a effectuer                                        
        if change :
            # On echange les sommets nodeA et nodeB
            partitionsList = switchNodes(partitionsList,nodeA,nodeB)
            updateNeighbors(nodeA,nodeB,nodesOnLimit,neighborsList,partitionsList[0],partitionsList[1],graph)
            
            GainGlobalFictif = GainGlobalFictif - gainAB
            if verbose:
                print "Les noeuds",nodeA,"et",nodeB, "ont été échangés"
                print "Gain fictif =", GainGlobalFictif
            
            if GainGlobalFictif < globalMin and GainGlobalFictif > 0:
                globalMin = GainGlobalFictif
                print "Update globalMin =",globalMin
                P1Final = list(partitionsList[0])
                P2Final = list(partitionsList[1])
        
        # cas où la remontee de temperature n'a que fait dégrader la solution
        if remontee == remonteeMax and not change :
            if verbose:
                print "Degradation trop élevée --> récupération des anciennes partitions"
            # récupération de la meilleure partition
            partitionsList[0] = list(P1Final)
            partitionsList[1] = list(P2Final)
            nodesOnLimit,neighborsList = neighbors(partitionsList[0],graph)
        
        addRandomNode(nodesOnLimit, partitionsList[0])
        addRandomNode(neighborsList, partitionsList[1])        
        
        iterationsC +=1
        tempC = 0.99*tempC
    

    deltaTime += time.time()
    deltaTime0 += time.time()
    if verbose:
        print "Partition Finale 1:", P1Final
        print "Partition Finale 2:", P2Final    
    print "Temps d'exécution recuit-simule:", deltaTime
    print "Temps d'exécution global:", deltaTime0
    print "Global cut:", globalMin