Modèle de Schelling

Fermé

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021 - 20 mai 2021 à 23:33
yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 - 25 mai 2021 à 09:03

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.

A voir également:

Modèle de Schelling
Modèle organigramme word - Guide
Modèle fiche de pointage excel - Télécharger - Tableur
Iphone dernier modèle - Guide
Modèle d'accusé de réception mail - Guide
Modèle de webcam - Guide

15 réponses

Réponse 1 / 15

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
21 mai 2021 à 11:26

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.

Réponse 2 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
21 mai 2021 à 20:51

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.

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
21 mai 2021 à 20:58

si je lis le code, vous ne faites rien du tout avec ce taux.

Réponse 3 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
21 mai 2021 à 21:03

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

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
21 mai 2021 à 21:16

avez-vous remarqué le "sinon"?
inutile de recopier le code.
si vous savez à quoi il sert, expliquez-le en français.
sinon, modifiez-le.

Réponse 4 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
21 mai 2021 à 21:25

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?

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
21 mai 2021 à 21:27

pas d'interet, ou nuisible?

vous pouvez faire tout ce que vous voulez, pourquoi poser cette question?

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021 > yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024
22 mai 2021 à 22:20

Bonjour, 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?

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476 > Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
23 mai 2021 à 08:27

s'agit-il d'une question sur une partie du code existant?
quelle partie?

Oui de la fonction Evolution()

peux-tu partager le code modifié de cette fonction?

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question

Réponse 5 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
21 mai 2021 à 21:30

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?

Réponse 6 / 15

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
23 mai 2021 à 15:55

vous avez aussi une énorme erreur dans compilation()

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
Modifié le 23 mai 2021 à 18:09

Sur quelle ligne?

autour de la ligne 125.
le code n'affiche pas les données correctes.

Pourtant 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?

pourquoi as-tu choisi d'afficher en 4 couleurs plutôt qu'en 5?

Pour qu'on identifie plus facilement les insatisfaits.

Réponse 7 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
23 mai 2021 à 22:34

En changeant je ne vois pas mieux, par contre même pour un seuil de 0 j'ai des cases d'insatisfaits...

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
24 mai 2021 à 09:25

qu'en déduis-tu?

Réponse 8 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
24 mai 2021 à 11:49

Que la mise en couleur est pas bonne mais je ne vois pas mon erreur.

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
24 mai 2021 à 12:38

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.

Réponse 9 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
Modifié le 24 mai 2021 à 14:44

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))

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
24 mai 2021 à 18:31

l'étape suivante, c'est d'utiliser cette fonction dans le code principal.

Réponse 10 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
24 mai 2021 à 19:01

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))

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
24 mai 2021 à 19:33

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.

Réponse 11 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
24 mai 2021 à 20:47

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...

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
24 mai 2021 à 21:13

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.

Réponse 12 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
Modifié le 24 mai 2021 à 21:21

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.

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
24 mai 2021 à 21:19

penses-tu que nous puissions deviner ce que tu as changé dans le code?

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
24 mai 2021 à 22:09

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.

Réponse 13 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
24 mai 2021 à 21:29

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

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
24 mai 2021 à 21:57

je ne suis pas convaincu que tu as tenu compte de ma deuxième remarque.

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476 > yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024
Modifié le 24 mai 2021 à 22:03

ni la quatrième, je pense.

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
24 mai 2021 à 22:06

en ligne 28, penses-tu qu'il soit possible de que les premières conditions soient simultanément vérifiées?

Non elles ne le sont pas car pour une case vide le taux de similarité est de 0.

Réponse 14 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
24 mai 2021 à 22:00

Alors c'est que j'ai mal compris ce que vous vouliez dire. Est-ce que vous pouvez me réexpliquer svp?

yg_be Messages postés 22720 Date d'inscription lundi 9 juin 2008 Statut Contributeur Dernière intervention 23 avril 2024 1 476
24 mai 2021 à 22:03

qu'as-tu compris?

La 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).

ce n'est pas ce que fait la ligne 42.

Pourtant c'est bien ce que j'ai codé: if TauxSimilarité(M,Nx,Ny,n) >= seuil:

ce n'est pas ce que devrait faire la ligne 42.

Réponse 15 / 15

Cleabvt Messages postés 29 Date d'inscription jeudi 20 mai 2021 Statut Membre Dernière intervention 25 mai 2021
24 mai 2021 à 22:15

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

Pix

Création gratuite de trombinoscope

MODELE BON A TIRER

Connaitre la date d'une photo.

Discussions similaires

Newsletters