Modèle de Schelling

Cleabvt -  
Bonjour,

Dans le cadre d'un projet en informatique nous devons nous inspirer du modèle de ségrégation de Schelling pour modéliser l'évolution d'une population (dans notre cas il s'agit d'une population de gnous et de zèbres). Cependant, lors de notre modélisation nous ne comprenons pas pourquoi des individus restent insatisfaits alors qu'ils pourraient bouger sur des cases où ils deviendraient satisfaits. Voici notre code: 

import random as rd
import matplotlib.pyplot as pl
import numpy as np

#Nous avons crée une matrice aléatoire:

def savaneground(x1,x2,n):
     g=x1/1200000#[https://www.commentcamarche.net/download/telecharger-34083102-pourcentage pourcentage] de gnous
     z=x2/1200000#pourcentage de zèbres
     nvg = int(g*n*n)
     nvz = int(z*n*n)
     nv0 = n*n - nvg - nvz
     L = nvg*[1] + nvz*[2] + nv0*[0]#nombre de 0, 1 et 2 dans la matrice
     rd.shuffle(L)#on mélange la liste
     return np.reshape(np.array(L, dtype=int), (n,n))

#Etudié les voisins de chaque case (nombre de cases voisines, d'individus de type 1 ou 2). Au final nous retournons une matrice de liste à 3 valeurs:

def voisins(M, x, y,n):
     V = [0, 0, 0]
     for Dx in (-1, 0, 1):
          for Dy in (-1, 0, 1):
               if (Dx, Dy) != (0,0):
                      xx = x + Dx
                      yy = y + Dy
                      if (xx >= 0) and (xx < n) and (yy >= 0) and (yy < n):
                           V[0] = V[0] + 1
                           a = M[xx,yy]
                           if a != 0 :
                                V[a] = V[a] + 1
     return V

def NbVoisins(M,n):
     R = np.zeros((n,n,3), dtype=int)
     for x in range(n):
          for y in range(n):
               for tp in (0,1, 2):
                    R[x, y, tp] = voisins(M, x, y, n)[tp]
     return R

#Puis nous regardons de taux de similaires:

def TauxSimilaires(M,n):
     R = np.zeros((n,n))
     NbV = NbVoisins(M,n)
     for x in range(n):
          for y in range(n):
               if M[x,y]!=0:
                    tp = M[x,y]
                    if (NbV[x,y,1]+NbV[x,y,2])!=0:
                         R[x,y] = NbV[x,y,tp]/(NbV[x,y,1]+NbV[x,y,2])
                    else:
                         R[x,y]=0
              else:
                    R[x,y]=0
     return R

#Si ce taux est inférieur à un seuil, l'individu bouge sur la matrice:

def Evolution (M,seuil,n):
     TS = TauxSimilaires(M,n)
     for x in range(n):
          for y in range(n):
               a = M[x,y]
               if a != 0 and TS[x,y] < seuil:
                    Nx = rd.randint(0,n-1)
                    Ny = rd.randint(0,n-1)
                    if M[Nx, Ny] == 0 & (Nx!=x or Ny!=y):
                         lv = voisins(M, Nx, Ny,n)
                         if (lv[1]+lv[2])!=0:
                             pv = lv[a]/(lv[1]+lv[2])
                             if pv>seuil :
                                  M[x,y] = 0
                                  M[Nx,Ny] = a
                             else:
                                   pv=0
                                   M[x,y] = 0
                                   M[Nx,Ny] = a
     return M

#Puis nous compilons nos fonctions pour modéliser l'évolution:

def CouleursIni(M,n):
     sol=(1,0.8,0.3)
     gnous=(0.8,0.4,0)
     zèbres=(0.5, 0.5, 0.5)
     Aff = np.zeros((n,n),dtype=int)
     for x in range(n):
          for y in range(n):
                if M[x,y] == 0: # rien
                      Aff[x,y,:] = sol
                elif M[x,y] == 1:
                      Aff[x,y,:] = zèbres
                elif M[x,y] == 2:
                      Aff[x,y,:] = gnous
     return Aff

def Couleurs(M, TS,n,seuil):
      Aff = np.zeros((n,n,3),dtype=np.uint8)
      for x in range(n):
            for y in range(n):
                  if M[x,y] == 0:
                       Aff[x,y,:] = (220,215,80)
                  else:
                       if TS[x,y]>seuil:
                            if M[x,y]==1:
                                  Aff[x,y,:] = (167,110,20)
                           elif M[x,y]==2:
                                  Aff[x,y,:] = (200,200,200)
                           else:
                                  Aff[x,y,:] = (128,128,128)
     return Aff

def compilation(n,x1,x2,seuil,ite):
     M=savaneground(x1,x2,n)
     TS=TauxSimilaires(M,n)
     pl.ion()
     pl.figure(1)
     image = pl.imshow(Couleurs(M,TS,n,seuil))
     pl.show()
     pl.pause(0.01)
     i=0
     while pl.fignum_exists(1) and i<ite:
           M =Evolution(M,seuil,n)
           image.set_data(Couleurs(M,TS,n,seuil))
           image.changed()
           pl.draw()
           pl.pause(0.01)
           i=i+1
     pl.ioff()
     pl.show()

print(compilation(50,200000,200000,0.2,70))


Nous pensons que notre erreur provient de la dernière fonction Evolution. En tout si quelqu'un voit où est notre problème nous serons ravi de communiquer avec lui. Merci d'avance pour votre aide. Très cordialement.

15 réponses

  • Votes
  • Date
  • Date décroissante
Résumé de la discussion

Dans ce modèle de ségrégation de Schelling appliqué à des gnous et des zèbres, certains agents demeurent insatisfaits malgré la possibilité apparente de se déplacer vers des cases plus compatibles. Le code calcule un taux de similitude par cellule et déclenche un déplacement lorsque ce taux est inférieur au seuil, mais ce taux n’est pas réévalué après chaque mouvement. Des observations montrent que la fonction TauxSimilaires est mal utilisée et que le tableau TS n’est pas recalculé après chaque modification de M, ce qui empêche les relocations de réagir correctement. En pratique, il est recommandé de recalculer TS après chaque déplacement, ou de lier les décisions à un taux de similitude mis à jour dynamiquement et vérifier les chemins possibles.

Bobot (l’IA à votre service)
  1. yg_be Contributeur
    bonjour,
    je ne comprends pas ce que vous essayez de faire avec pv dans Evolution().
    plus précisément, il me semble qu'il ne sert à rien.
    1. Cleabvt Auteur
      pv nous permet de recalculer le taux de similaire sur la case potentielle, c'est-à-dire la case vers laquelle nous déplacerions notre individu.
      1. yg_be Contributeur
        si je lis le code, vous ne faites rien du tout avec ce taux.
    2. Cleabvt Auteur
      On le compare au seuil pour pouvoir changer la case dans ces lignes ci: if pv>seuil :M[x,y] = 0 M[Nx,Ny] = a
      1. yg_be Contributeur
        avez-vous remarqué le "sinon"?
        inutile de recopier le code.
        si vous savez à quoi il sert, expliquez-le en français.
        sinon, modifiez-le.
    3. Cleabvt Auteur
      Ah merci, en effet le sinon n'a pas d'intérêt. Mais est-ce qu'on ne pourrait pas faire une boucle for pour rechercher une case dans toute la matrice et ne pas en regarder une seule au hasard?
      1. yg_be Contributeur
        pas d'interet, ou nuisible?

        vous pouvez faire tout ce que vous voulez, pourquoi poser cette question?
      2. Cleabvt Auteur
        @yg_beBonjour, je reviens vers vous car nous n'arrivons pas à modéliser la recherche aléatoire d'une case tant que celle-ci ne satisfait pas les critères (qu'elle soit différente de 0 et au dessus du seuil)... Avez-vous une idée de comment nous pourrions faire?
      3. yg_be Contributeur
        @Cleabvts'agit-il d'une question sur une partie du code existant?
        quelle partie?
      4. Cleabvt Auteur
        @yg_beOui de la fonction Evolution()
      5. yg_be Contributeur
        @Cleabvtpeux-tu partager le code modifié de cette fonction?
    5. Cleabvt Auteur
      Je voulais dire nous voulons trouver une case au hasard or là notre code ne regarde qu'une seule case (et une boucle for regarderait les cases dans l'ordre). Comment pouvons-nous faire cela?
      1. yg_be Contributeur
        vous avez aussi une énorme erreur dans compilation()
        1. Cleabvt Auteur
          Sur quelle ligne?
        2. yg_be Contributeur
          @Cleabvtautour de la ligne 125.
          le code n'affiche pas les données correctes.
        3. Cleabvt Auteur
          @yg_bePourtant j'ai bien utilisé comme on me l'a appris l'affichage successif des matrices. Est-ce que vous pourriez me guider pour que je corrige mon erreur?
        4. yg_be Contributeur
          @Cleabvtpourquoi as-tu choisi d'afficher en 4 couleurs plutôt qu'en 5?
        5. Cleabvt Auteur
          @yg_bePour qu'on identifie plus facilement les insatisfaits.
      2. Cleabvt Auteur
        En changeant je ne vois pas mieux, par contre même pour un seuil de 0 j'ai des cases d'insatisfaits...
        1. yg_be Contributeur
          qu'en déduis-tu?
      3. Cleabvt Auteur
        Que la mise en couleur est pas bonne mais je ne vois pas mon erreur.
        1. yg_be Contributeur
          eh bien, tu progresses, au début: "nous ne comprenons pas pourquoi des individus restent insatisfaits alors qu'ils pourraient bouger sur des cases où ils deviendraient satisfaits"

          maintenant, tu as réalisé que le soucis était la mise en couleur, la détermination de la satisfaction.

          tu as écrit un code inutilement compliqué, dans lequel tu ne te retrouves plus. trop de fonctions, trop de matrices.
          tu pourrais essayer de comprendre ce qu'il fait, et le corriger.
          je suggère plutôt de le simplifier.

          les trois fonctions voisins(), NbVoisins() et TauxSimilaires() font trop de choses et sont incorrectement utilisées.

          je suggère de les remplacer par une fonction qui calcule le taux de similitude pour un individu dans une case.
      4. Cleabvt Auteur
        Tout d'abord merci pour votre aide. Voici une fonction plus simple pour le calcul du taux de similarité: 
        def TauxSimilarité(M,x,y,n):
    s=0
    t=0
    a=M[x,y]
    if M[x,y]!=0:
        for Dx in (-1, 0, 1):
            for Dy in (-1, 0, 1):
                if (Dx, Dy) != (0,0):
                    xx = x + Dx
                    yy = y + Dy
                    if (xx >= 0) and (xx < n) and (yy >= 0) and (yy < n):
                        if M[xx,yy]==a:
                            s+=1
                            t+=1
                        elif M[xx,yy]!=0:
                            t+=1
    return s/t
M=np.array([[1,2],[1,1]])
print(TauxSimilarité(M,1,1, 2))
        1.  yg_be Contributeur
          l'étape suivante, c'est d'utiliser cette fonction dans le code principal.
      5. Cleabvt Auteur
        Je n'ai pas l'impression que cela marche mieux... 

        import random as rd
import matplotlib.pyplot as pl
import numpy as np


def savaneground(g,z,n):
     
     nvg = int(g*n*n)
     nvz = int(z*n*n)
     nv0 = n*n - nvg - nvz
     L = nvg*[1] + nvz*[2] + nv0*[0]
     rd.shuffle(L)
     return np.reshape(np.array(L, dtype=int), (n,n))

def TauxSimilarité(M,x,y,n):
    s=0
    t=0
    a=M[x,y]
    for Dx in (-1, 0, 1):
        for Dy in (-1, 0, 1):
            if (Dx, Dy) != (0,0):
                xx = x + Dx
                yy = y + Dy
                if (xx >= 0) and (xx < n) and (yy >= 0) and (yy < n):
                    if M[xx,yy]==a:
                        s+=1
                        t+=1
                    elif M[xx,yy]!=0:
                        t+=1
                    else:
                        return 0
    return s/t


def Evolution (M,seuil,n):
     for x in range(n):
          for y in range(n):
              if M[x,y] != 0 and TauxSimilarité(M,x,y,n) < seuil:
                    Nx = rd.randint(0,n-1)
                    Ny = rd.randint(0,n-1)                   
                    if M[Nx, Ny] == 0 and (Nx!=x or Ny!=y):
                         if TauxSimilarité(M,Nx,Ny,n) >= seuil:
                             M[Nx,Ny]=M[x,y]
                             M[x,y]=0
                             
     return M
#M=np.array([[0,0],[1,2]])
print(Evolution(M,0.2,2))
#Puis nous compilons nos fonctions pour modéliser l'évolution:

def CouleursIni(M,n):
     sol=(1,0.8,0.3)
     gnous=(0.8,0.4,0)
     zèbres=(0.5, 0.5, 0.5)
     Aff = np.zeros((n,n),dtype=int)
     for x in range(n):
          for y in range(n):
                if M[x,y] == 0: # rien
                      Aff[x,y,:] = sol
                elif M[x,y] == 1:
                      Aff[x,y,:] = zèbres
                elif M[x,y] == 2:
                      Aff[x,y,:] = gnous
     return Aff

def Couleurs(M,n,seuil):
      Aff = np.zeros((n,n,3),dtype=np.uint8)
      for x in range(n):
            for y in range(n):
                  if M[x,y] == 0:
                       Aff[x,y,:] = (220,215,80)
                  else:
                       if TauxSimilarité(M,x,y,n)>seuil:
                            if M[x,y]==1:
                                  Aff[x,y,:] = (167,110,20)
                            elif M[x,y]==2:
                                  Aff[x,y,:] = (200,200,200)
                       else:
                            Aff[x,y,:] = (128,128,128)
      return Aff

def compilation(n,x1,x2,seuil,ite):
     M=savaneground(x1,x2,n)
     pl.ion()
     pl.figure(1)
     image = pl.imshow(Couleurs(M,n,seuil))
     pl.show()
     pl.pause(0.01)
     i=0
     while pl.fignum_exists(1) and i<ite:
           M=Evolution(M,seuil,n)
           image.set_data(Couleurs(M,n,seuil))
           image.changed()
           pl.draw()
           pl.pause(0.01)
           i=i+1
     pl.ioff()
     pl.show()

print(compilation(8,0.2,0.2,0,2))
        1. yg_be Contributeur
          quel est le but des lignes 30 et 31?

          la fonction TauxSimilarité() n'est pas adaptée à l'usage qui en est fait en ligne 42.

          le code contient contient aussi plusieurs tests inutiles: lignes 41 et 76.

          affiche en 5 couleurs, c'est plus clair.

          regarde bien les tests faits en 38, 42 et 73, il y a une anomalie.
      6. Cleabvt Auteur
        Les lignes 30 et 31 m'évitent de diviser par 0. Pour la ligne 42 je ne sais pas comment comparer le seuil si je n'utilise pas cette fonction. La ligne 41 permet de regarder seulement les cases sans nombre. L'anomalie se trouve dans l'utilisation de la fonction TauxSimilarité mais je ne sais pas comment faire autrement...
        1. yg_be Contributeur
          les lignes 30 et 31 sont une mauvaise méthode pour éviter de diviser par zéro.

          c'est l'inégalité en ligne 42 qui est incompatible avec celles des lignes 38 et 73.

          le deuxième test en ligne 41 est inutile, vu le premier test en ligne 38.

          réfléchis bien aux différences entre les deux appels à TauxSimilarité() dans les lignes 38 et 42.
      7. Cleabvt Auteur
        La ligne 42 me permet pourtant de trouver une case avec un seuil satisfaisant non? Entre les lignes 41 et 38 je change d'index je prend Nx et Ny au lieu de x et y. Cependant, j'aimerais parcourir la matrice aléatoirement jusqu'à trouver une valeur or la je regarde une seule valeur... De plus, en tenant compte de vos modifications des individus insatisfaits apparaissent encore même avec un seuil de similarité à 0 ce qui ne devrait pas être le cas.
        1. yg_be Contributeur
          penses-tu que nous puissions deviner ce que tu as changé dans le code?
        2. yg_be Contributeur
          qu'appeles-tu précisément "satisfaisant"? il me semble que cette définition varie d'un endroit à l'autre.
          l'absence de documentation et de commentaire n'aide pas, bien sûr.
      8. Cleabvt Auteur 
        def TauxSimilarité(M,x,y,n):
    s=0
    t=0
    a=M[x,y]
    for Dx in (-1, 0, 1):
        for Dy in (-1, 0, 1):
            if (Dx, Dy) != (0,0):
                xx = x + Dx
                yy = y + Dy
                if (xx >= 0) and (xx < n) and (yy >= 0) and (yy < n):
                    if M[xx,yy]==a:
                        s+=1
                        t+=1
                    elif M[xx,yy]!=0:
                        t+=1
    if t!=0:
        return s/t
    else:
        return 0


def Evolution (M,seuil,n):
     for x in range(n):
          for y in range(n):
              if M[x,y] != 0 and TauxSimilarité(M,x,y,n) < seuil:
                    for Nx in range (n):
                        for Ny in range (n):                                              
                            if M[Nx, Ny] == 0 and (Nx!=x or Ny!=y) and TauxSimilarité(M,Nx,Ny,n) >= seuil:
                                M[Nx,Ny]=M[x,y]
                                M[x,y]=0
                             
     return M
        1.  yg_be Contributeur
          je ne suis pas convaincu que tu as tenu compte de ma deuxième remarque.
        2. yg_be Contributeur
          @yg_beni la quatrième, je pense.
        3. yg_be Contributeur
          en ligne 28, penses-tu qu'il soit possible de que les premières conditions soient simultanément vérifiées?
        4. Cleabvt Auteur
          @yg_beNon elles ne le sont pas car pour une case vide le taux de similarité est de 0.
      9. Cleabvt Auteur
        Alors c'est que j'ai mal compris ce que vous vouliez dire. Est-ce que vous pouvez me réexpliquer svp?
        1. yg_be Contributeur
          qu'as-tu compris?
        2. Cleabvt Auteur
          @yg_beLa ligne 42 regarde pour une case 0 le taux de similarité de celle-ci or pour une case 0 le taux de similarité est de 0 donc forcément inférieur au taux que j'imposerais (en admettant d'en choisir un non nul).
        3. yg_be Contributeur
          @Cleabvtce n'est pas ce que fait la ligne 42.
        4. Cleabvt Auteur
          @yg_bePourtant c'est bien ce que j'ai codé: if TauxSimilarité(M,Nx,Ny,n) >= seuil:
        5. yg_be Contributeur
          @Cleabvtce n'est pas ce que devrait faire la ligne 42.
      10. Cleabvt Auteur
        Si nous reprenons le code initial: 

        import random as rd
import matplotlib.pyplot as pl
import numpy as np

#Nous avons crée une matrice aléatoire:

def savaneground(x1,x2,n):
     g=x1/1200000#[https://www.commentcamarche.net/download/telecharger-34083102-pourcentage pourcentage] de gnous
     z=x2/1200000#pourcentage de zèbres
     nvg = int(g*n*n)
     nvz = int(z*n*n)
     nv0 = n*n - nvg - nvz
     L = nvg*[1] + nvz*[2] + nv0*[0]#nombre de 0, 1 et 2 dans la matrice
     rd.shuffle(L)#on mélange la liste
     return np.reshape(np.array(L, dtype=int), (n,n))

#Etudié les voisins de chaque case (nombre de cases voisines, d'individus de type 1 ou 2). Au final nous retournons une matrice de liste à 3 valeurs:

def voisins(M, x, y,n):
     V = [0, 0, 0]
     for Dx in (-1, 0, 1):
          for Dy in (-1, 0, 1):
               if (Dx, Dy) != (0,0):
                      xx = x + Dx
                      yy = y + Dy
                      if (xx >= 0) and (xx < n) and (yy >= 0) and (yy < n):
                           V[0] = V[0] + 1
                           a = M[xx,yy]
                           if a != 0 :
                                V[a] = V[a] + 1
     return V

def NbVoisins(M,n):
     R = np.zeros((n,n,3), dtype=int)
     for x in range(n):
          for y in range(n):
               for tp in (0,1, 2):
                    R[x, y, tp] = voisins(M, x, y, n)[tp]
     return R

#Puis nous regardons de taux de similaires:

def TauxSimilaires(M,n):
     R = np.zeros((n,n))
     NbV = NbVoisins(M,n)
     for x in range(n):
          for y in range(n):
               if M[x,y]!=0:
                    tp = M[x,y]
                    if (NbV[x,y,1]+NbV[x,y,2])!=0:
                         R[x,y] = NbV[x,y,tp]/(NbV[x,y,1]+NbV[x,y,2])
                    else:
                         R[x,y]=0
              else:
                    R[x,y]=0
     return R

#Si ce taux est inférieur à un seuil, l'individu bouge sur la matrice:

def Evolution (M,seuil,n):
     TS = TauxSimilaires(M,n)
     for x in range(n):
          for y in range(n):
               a = M[x,y]
               if a != 0 and TS[x,y] < seuil:
                    Nx = rd.randint(0,n-1)
                    Ny = rd.randint(0,n-1)
                    if M[Nx, Ny] == 0 & (Nx!=x or Ny!=y):
                         lv = voisins(M, Nx, Ny,n)
                         if (lv[1]+lv[2])!=0:
                             pv = lv[a]/(lv[1]+lv[2])
                             if pv>seuil :
                                  M[x,y] = 0
                                  M[Nx,Ny] = a
                             else:
                                   pv=0
                                   M[x,y] = 0
                                   M[Nx,Ny] = a
     return M

#Puis nous compilons nos fonctions pour modéliser l'évolution:

def CouleursIni(M,n):
     sol=(1,0.8,0.3)
     gnous=(0.8,0.4,0)
     zèbres=(0.5, 0.5, 0.5)
     Aff = np.zeros((n,n),dtype=int)
     for x in range(n):
          for y in range(n):
                if M[x,y] == 0: # rien
                      Aff[x,y,:] = sol
                elif M[x,y] == 1:
                      Aff[x,y,:] = zèbres
                elif M[x,y] == 2:
                      Aff[x,y,:] = gnous
     return Aff

def Couleurs(M, TS,n,seuil):
      Aff = np.zeros((n,n,3),dtype=np.uint8)
      for x in range(n):
            for y in range(n):
                  if M[x,y] == 0:
                       Aff[x,y,:] = (220,215,80)
                  else:
                       if TS[x,y]>seuil:
                            if M[x,y]==1:
                                  Aff[x,y,:] = (167,110,20)
                           elif M[x,y]==2:
                                  Aff[x,y,:] = (200,200,200)
                           else:
                                  Aff[x,y,:] = (128,128,128)
     return Aff

def compilation(n,x1,x2,seuil,ite):
     M=savaneground(x1,x2,n)
     TS=TauxSimilaires(M,n)
     pl.ion()
     pl.figure(1)
     image = pl.imshow(Couleurs(M,TS,n,seuil))
     pl.show()
     pl.pause(0.01)
     i=0
     while pl.fignum_exists(1) and i<ite:
           M =Evolution(M,seuil,n)
           image.set_data(Couleurs(M,TS,n,seuil))
           image.changed()
           pl.draw()
           pl.pause(0.01)
           i=i+1
     pl.ioff()
     pl.show()

print(compilation(50,200000,200000,0.2,70))


        Le problème de ce code est la présence d'insatisfaits pour le seuil 0 . Si nous reprenons les échanges précédents je ne vois pas d'erreur dans la mise en couleur il s'agit donc d'une autre erreur mais je ne la trouve pas. Pourriez-vous plutôt me guider sur ce code?

        Discussions similaires

        Caler une adresse au niveau de la fenêtre d'une enveloppe
        ®omain

        15 réponses
        Création gratuite de trombinoscope
        Poka

        17 réponses