es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

¿Cómo hacer que el bucle genere el tamaño correcto del array de salida?

31 May, 2023 Programación

En mi bucle tengo tres variables diferentes que necesito producir: A, el promedio de V y Alpha. Antes solo estaba obteniendo un valor para cada uno, pero lo arreglé usando la función append.

En cuanto a la indentación, esperaría que A, Vav y Alpha sean matrices 1d de tamaño t, r y MM respectivamente. Sin embargo, para A obtengo un tamaño de trMM, y para Vav un tamaño de r*MM. ¿Cómo hago para que los tamaños correspondan a ciertas secciones del bucle?

An=np.array([51,101,201,301,501]) #Número de agentes
t=10 #pasos de tiempo
MM=3 #memoria del agente
r=5 #repeticiones
A=np.array([])
V=np.array([])
Alpha=np.array([])
Vav=np.array([])

for agentcount in np.arange(0,5): #Contador de agentes
    N=An[agentcount]

    for M in np.arange(1,MM+1):
        for crep in np.arange(1,r+1): 
             win=(np.random.rand(M,1)>0.5).astype(int) #Registro de victorias
             s1=(np.random.rand(2**M,N)>0.5).astype(int) #estrategia aleatoria
             s2=(np.random.rand((2**M),N)>0.5).astype(int) #alternativa
             payout=np.zeros([2,N]) #registro de pagos vacío
             
             for tc in np.arange(1,t+1):
                  cc=np.abs((1+ np.dot((2**(np.arange(0,M))),win)))
                  nex1=s1[cc-1,:].reshape(501)
                  nex2=s2[cc-1,:].reshape(501)
                  nexts=np.stack((nex1,nex2),axis=0)

                  for cn in np.arange(0,N+1): #mejor estrategia
                      if (payout[0,cn-1]>payout[1,cn-1]):
                          Next=nex1
                      else:
                          Next=nex2
                  Asum=np.sum(Next)/N
                  A=np.append(A,Asum)
                  winning=(A<0.5).astype(int)
                  winning=np.transpose(winning)
                  payout=payout+(nexts==winning) #actualizar registro

             V=np.append(V,np.var(A[-t:])) #solo tomar los últimos t valores
             Vav=np.append(Vav,np.mean(V[(crep-1)*MM*M+M-1:crep*MM*M])) 
             #toma valores desde crep pasado hasta ahora
             
        Alpha=np.append(Alpha,2**M/N)
Tags:  , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Para hacer que los tamaños de A, Vav y Alpha correspondan a ciertas secciones del bucle, es necesario utilizar listas anidadas y agregar los valores a la sublista adecuada en cada iteración del bucle. Por ejemplo:

    A = [[] for i in range(MM)] #crear lista anidada para A
Vav = [[] for i in range(r)] #crear lista anidada para Vav

for agentcount in np.arange(0,5):
    N=An[agentcount]

    for M in np.arange(1,MM+1):
        Alpha = 2**M/N

        for crep in np.arange(1,r+1): 
             win=(np.random.rand(M,1)>0.5).astype(int) #registro de victorias 
             s1=(np.random.rand(2**M,N)>0.5).astype(int) #estrategia aleatoria
             s2=(np.random.rand((2**M),N)>0.5).astype(int) #alternativa 
             payout=np.zeros([2,N])#registro de pagos vacío

             for tc in np.arange(1,t+1):
                  cc=np.abs((1+ np.dot((2**(np.arange(0,M))),win)))
                  nex1=s1[cc-1,:].reshape(N)
                  nex2=s2[cc-1,:].reshape(N)
                  nexts=np.stack((nex1,nex2),axis=0)

                  for cn in np.arange(0,N): #mejor estrategia
                      if (payout[0,cn]>payout[1,cn]):
                          Next=nex1
                      else:
                          Next=nex2

                  Asum=np.sum(Next)/N

                  A[M-1].append(Asum) #agregar a la lista anidada para A

                  winning=(Asum<0.5).astype(int)
                  winning=np.transpose(winning)
                  payout=payout+(nexts==winning) #actualizar registro

             V = np.var(A[M-1])
             Vav[crep-1].append(V) #agregar a la lista anidada para Vav

    En este código, creamos listas anidadas para A y Vav, con la lista externa correspondiente al bucle sobre MM o r, respectivamente, y la lista interna correspondiente al bucle sobre t. Agregamos los valores a la sublista adecuada en cada iteración del bucle utilizando la función append(). También ajustamos el índice de A y Vav para que coincida con la estructura de lista anidada.

Comments are closed.