1. Este site usa cookies. Ao continuar a usar este site está a concordar com o nosso uso de cookies. Saber Mais.

Ajuda em python.

Discussão em 'Programação' iniciada por simjohn, 7 de Novembro de 2012. (Respostas: 1; Visualizações: 594)

  1. simjohn

    simjohn Power Member

    Boas, este exercicio tá a dar comigo em doido.
    Eu sei que até pode estar um pouco ineficiente,, mas neste momento só me preocupo em por isto a funcionar. eu tenho dois array e uma lista, o array espaco é onde eu tenho a recompensas de estar em cada casa, o array utilidade é inicializado a 0 e deve ser atualizado à medida que eu vou calculando as utilidades e a lista accao é onde eu guardo a accao referente a cada utilidade ou seja andar para cima, baixo, esquerda ou direita. mas sempre que eu corro o programa não é isso que isto faz.
    o FD é o factor de desconto é um valor entre 0 e 1, eu utilizo 0.5, e o E é o erro eu uso 5, que é para isto não demorar muito tempo a executar.
    Algum "cranio" em python me pode ajudar?
    Código:
    import numpy as np
    import scipy as sp
    import matplotlib as ml
    espaco=np.array([0,6,1,0,2,2,3,0,0,0,1,3,1,0,0,0,4,2,2,5,0,1,1,0]).reshape(4,6)
    accao=list()
    utilidade=np.array([0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]).reshape(4,6)
    PAndar=0.5
    PParado=0.2
    PSeguirOutra=0.3
    
    
    FD= float(raw_input("Qual o fator de desconto?"))
    E= float(raw_input("Qual o erro maximo a tolerar?"))
    x,y=0,0
    
    
    #iteração de valor
    
    
    
    
    
    
    def Vmax(x,y):
                         
                         if (x==0 and y==0):
                            D, B = 0,0
                            D=PParado*espaco[x,y]+PAndar*utilidade[x,y+1]+PSeguirOutra*utilidade[x+1,y]
                            B=PParado*espaco[x,y]+PAndar*utilidade[x+1,y]+PSeguirOutra*utilidade[x,y+1]
                            if (max(D,B)==D):
                                accao.append("direita")
                                #y=y+1
                            else:
                                accao.append("baixo")
                                #x=x+1
                            return max (D,B)
                         elif (x==0 and y!=0 and y!=4 and y!=5):
                            D, E=0,0
                            D=PParado*espaco[x,y]+PAndar*utilidade[x,y+1]+PSeguirOutra*utilidade[x,y-1]
                            E=D=PParado*espaco[x,y]+PAndar*utilidade[x,y-1]+PSeguirOutra*utilidade[x,y+1]
                            if (max(D,E)==D):
                                accao.append("direita")
                                #y=y+1
                            else:
                                accao.append("esquerda")
                                #y=y-1
                            return max (D,E)
                         elif (x==0 and y==4):
                             E,D,B=0,0,0
                             D=PParado*espaco[x,y]+PAndar*utilidade[x,y+1]+(PSeguirOutra/2)*utilidade[x,y-1]+(PSeguirOutra/2)*utilidade[x+1,y]
                             E=PParado*espaco[x,y]+PAndar*utilidade[x,y-1]+(PSeguirOutra/2)*utilidade[x,y+1]+(PSeguirOutra/2)*utilidade[x+1,y]
                             B=PParado*espaco[x,y]+PAndar*utilidade[x+1,y]+(PSeguirOutra/2)*utilidade[x,y-1]+(PSeguirOutra/2)*utilidade[x,y+1]
                             if (max(D,B,E)==D):
                                accao.append("direita")
                                #y=y+1
                             elif(max(D,B,E)==B):
                                accao.append("baixo")
                                x=x+1
                             else:
                                  accao.append("esquerda")
                                  #y=y-1
                             return max (E,D,B)
                         elif (x==0 and y==5):
                             E,B=0,0
                             E=PParado*espaco[x,y]+PAndar*utilidade[x,y-1]+PSeguirOutra*utilidade[x+1,y]
                             B=PParado*espaco[x,y]+PAndar*utilidade[x+1,y]+PSeguirOutra*utilidade[x,y-1]
                             if (max(E,B)==E):
                                accao.append("esquerda")
                                #y=y-1
                             else:
                                accao.append("baixo")
                                x=x+1
                             return max (E,B)
                         elif (x==1 and y==0):
                             C, B = 0,0
                             B=PParado*espaco[x,y]+PAndar*utilidade[x+1,y]+PSeguirOutra*utilidade[x-1,y]
                             C=PParado*espaco[x,y]+PAndar*utilidade[x-1,y]+PSeguirOutra*utilidade[x+1,y]
                             if (max(C,B)==C):
                                accao.append("cima")
                                #x=x-1
                             else:
                                accao.append("baixo")
                                #x=x+1
                             return max (C,B)
                         elif (x==1 and y==4):
                             C,B,D=0,0,0
                             C=PParado*espaco[x,y]+PAndar*utilidade[x-1,y]+(PSeguirOutra/2)*utilidade[x,y+1]+(PSeguirOutra/2)*utilidade[x+1,y]
                             B=PParado*espaco[x,y]+PAndar*utilidade[x+1,y]+(PSeguirOutra/2)*utilidade[x,y+1]+(PSeguirOutra/2)*utilidade[x-1,y]
                             D=PParado*espaco[x,y]+PAndar*utilidade[x,y+1]+(PSeguirOutra/2)*utilidade[x-1,y]+(PSeguirOutra/2)*utilidade[x+1,y]
                             if (max(C,D,B)==D):
                                accao.append("direita")
                                #y=y+1
                             elif (max(C,D,B)==B):
                                accao.append("baixo")
                                #x=x+1
                             else:
                                   accao.append("cima")
                                   #x=x-1
                             return max (C,B,D)
                         elif (x==1 and y==5):
                             C,B,E=0,0,0
                             C=PParado*espaco[x,y]+PAndar*utilidade[x-1,y]+(PSeguirOutra/2)*utilidade[x,y-1]+(PSeguirOutra/2)*utilidade[x+1,y]
                             B=PParado*espaco[x,y]+PAndar*utilidade[x+1,y]+(PSeguirOutra/2)*utilidade[x,y-1]+(PSeguirOutra/2)*utilidade[x-1,y]
                             E=PParado*espaco[x,y]+PAndar*utilidade[x,y-1]+(PSeguirOutra/2)*utilidade[x+1,y]+(PSeguirOutra/2)*utilidade[x-1,y]
                             if (max(C,E,B)==C):
                                accao.append("cima")
                                #x=x-1
                             elif (max(C,E,B)==E):
                                accao.append("esquerda")
                                #y=y-1
                             else:
                                   accao.append("baixo")
                                   #x=x+1
                             return max (C,B,E)
                         elif (x==2 and y==0):
                             C,B=0,0
                             B=PParado*espaco[x,y]+PAndar*utilidade[x+1,y]+PSeguirOutra*utilidade[x-1,y]
                             C=PParado*espaco[x,y]+PAndar*utilidade[x-1,y]+PSeguirOutra*utilidade[x-1,y]
                             if (max(C,B)==C):
                                accao.append("cima")
                                #x=x-1
                             else:
                                accao.append("baixo")
                                #x=x+1
                             return max (C,B)
                         elif (x==2 and y==4):
                             C,B,D=0,0,0
                             C=PParado*espaco[x,y]+PAndar*utilidade[x-1,y]+(PSeguirOutra/2)*utilidade[x,y+1]+(PSeguirOutra/2)*utilidade[x+1,y]
                             B=PParado*espaco[x,y]+PAndar*utilidade[x+1,y]+(PSeguirOutra/2)*utilidade[x,y+1]+(PSeguirOutra/2)*utilidade[x-1,y]
                             D=PParado*espaco[x,y]+PAndar*utilidade[x,y+1]+(PSeguirOutra/2)*utilidade[x-1,y]+(PSeguirOutra/2)*utilidade[x+1,y]
                             if (max(C,D,B)==D):
                                accao.append("direita")
                                #y=y+1
                             elif (max(C,D,B)==B):
                                accao.append("baixo")
                                #x=x+1
                             else:
                                   accao.append("direita")
                                   #y=y+1
                             return max (C,B,D)
                         elif (x==2 and y==5):
                             C,E,B=0,0,0
                             C=PParado*espaco[x,y]+PAndar*utilidade[x-1,y]+(PSeguirOutra/2)*utilidade[x,y-1]+(PSeguirOutra/2)*utilidade[x+1,y]
                             E=PParado*espaco[x,y]+PAndar*utilidade[x,y-1]+(PSeguirOutra/2)*utilidade[x+1,y]+(PSeguirOutra/2)*utilidade[x-1,y]
                             B=PParado*espaco[x,y]+PAndar*utilidade[x+1,y]+(PSeguirOutra/2)*utilidade[x-1,y]+(PSeguirOutra/2)*utilidade[x,y-1]
                             if (max(C,E,B)==C):
                                accao.append("cima")
                                #x=x-1
                             elif (max(C,E,B)==B):
                                accao.append("baixo")
                                #x=x+1
                             else:
                                   accao.append("esquerda")
                                   #y=y-1
                             return max (C,E,B)
                         elif (x==3 and y==0):
                             C,D=0,0
                             C=PParado*espaco[x,y]+PAndar*utilidade[x-1,y]+PSeguirOutra*utilidade[x,y+1]
                             D=PParado*espaco[x,y]+PAndar*utilidade[x,y+1]+PSeguirOutra*utilidade[x-1,y]
                             if (max(D,C)==D):
                                accao.append("direita")
                                #y=y+1
                             else:
                                accao.append("cima")
                                #x=x-1
                             return max (C,D)
                         elif (x==3 and y!=0 and y!=4 and y!=5):
                            D, E=0,0
                            D=PParado*espaco[x,y]+PAndar*utilidade[x,y+1]+PSeguirOutra*utilidade[x,y-1]
                            E=D=PParado*espaco[x,y]+PAndar*utilidade[x,y-1]+PSeguirOutra*utilidade[x,y+1]
                            if (max(D,E)==D):
                                accao.append("direita")
                                #y=y+1
                            else:
                                accao.append("esquerda")
                                #y=y-1
                            return max (D,E)
                         elif (x==3 and y==4):
                            C,D,E=0,0,0
                            D=PParado*espaco[x,y]+PAndar*utilidade[x,y+1]+(PSeguirOutra/2)*utilidade[x-1,y]+(PSeguirOutra/2)*utilidade[x,y-1]
                            C=PParado*espaco[x,y]+PAndar*utilidade[x-1,y]+(PSeguirOutra/2)*utilidade[x,y+1]+(PSeguirOutra/2)*utilidade[x,y-1]
                            E=PParado*espaco[x,y]+PAndar*utilidade[x,y-1]+(PSeguirOutra/2)*utilidade[x-1,y]+(PSeguirOutra/2)*utilidade[x,y+1]
                            if (max(D,E,C)==D):
                                accao.append("direita")
                                #y=y+1
                            elif (max(D,E,C)==E):
                                accao.append("esquerda")
                                #y=y-1
                            else:
                                  accao.append("cima")
                                  #x=x-1
                            return max (C,D,E)
                         elif (x==3 and y==5):
                            C,E=0,0
                            C=PParado*espaco[x,y]+PAndar*utilidade[x-1,y]+PSeguirOutra*utilidade[x,y-1]
                            E=PParado*espaco[x,y]+PAndar*utilidade[x,y-1]+PSeguirOutra*utilidade[x-1,y]
                            if (max(C,E)==C):
                                accao.append("cima")
                                #x=x-1
                            else:
                                accao.append("esquerda")
                                #y=y-1
                            return max (C,E)
                         else:
                            return 0
    
    
    def iteracaoValor():
     d,a,b,=0,0,0
     while d<(E*((1-FD)/FD)):
                 global x
                 global y
                 for i in espaco:
                     
                     utilidade[x,y]=espaco[x,y]+FD*Vmax(x,y)
    
    
                            
                 if (utilidade[x,y]-utilidade[a,b])>d:
                   d=(utilidade[x,y]-utilidade[a,b])
                   
                 a=x
                 b=y
                  
                
    
    
                 if (accao=="cima"):
                       x=x-1
                 elif (accao=="esquerda"):
                       y=y-1
                 elif (accao=="direita"):
                      y=y+1
                 elif (accao=="baixo"):
                     x=x+1
    
    
                 print x
                 print y
                 print utilidade
                 print accao
     return utilidade[x,y]
    
    
    iteracaoValor()
    print"A política que o robot deve seguir, utilizando a iteração de valor, é:%d\n " % iteracaoValor()
    
    
    
    
           
                             
    
    
    
     
  2. Geedunk

    Geedunk Power Member

    Assim por alto:

    no Vmax fazes um if sem alteração do valor x e y, por isso fica sempre a zero.
    no iteracaoValor, no ciclo for não fazes alteração nenhuma à formula, independentemente do "i" o valor vai ser sempre zero porque é o valor de x e y. A seguir à formula podes por um print utilidade e confirmar o que disse.

    Revê isso e se tiveres mais dúvidas diz. Atenção que pode haver mais coisas, vi só por alto.
     

Partilhar esta Página