Modèle de Schelling
Cleabvt
Messages postés
30
Statut
Membre
-
yg_be Messages postés 23437 Date d'inscription Statut Contributeur Dernière intervention -
yg_be Messages postés 23437 Date d'inscription Statut Contributeur Dernière intervention -
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:
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.
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
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.
-
yg_be Messages postés 23437 Date d'inscription Statut Contributeur Dernière intervention Ambassadeur 1 588
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. -
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.
-
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
-
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?
-
Vous n’avez pas trouvé la réponse que vous recherchez ?
Posez votre question -
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?
-
yg_be Messages postés 23437 Date d'inscription Statut Contributeur Dernière intervention Ambassadeur 1 588
vous avez aussi une énorme erreur dans compilation() -
En changeant je ne vois pas mieux, par contre même pour un seuil de 0 j'ai des cases d'insatisfaits...
-
Que la mise en couleur est pas bonne mais je ne vois pas mon erreur.
-
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.
-
-
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)) -
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))-
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.
-
-
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...
-
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.
-
-
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.
-
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 -
Alors c'est que j'ai mal compris ce que vous vouliez dire. Est-ce que vous pouvez me réexpliquer svp?
-
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?
